//! Script# Browser Compat Layer
//! Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
//! http://projects.nikhilk.net
//!

function __loadCompatLayer(w) {
    w.Debug = function() {
    };
    w.Debug._fail = function(message) {
        throw new Error(message);
    };
    w.Debug.writeln = function(text) {
        if (window.console) {
            if (window.console.debug) {
                window.console.debug(text);
                return;
            }
            else if (window.console.log) {
                window.console.log(text);
                return;
            }
        }
        else if (window.opera &&
            window.opera.postError) {
            window.opera.postError(text);
            return;
        }
    };

    w.__getNonTextNode = function(node) {
        try {
            while (node && (node.nodeType != 1)) {
                node = node.parentNode;
            }
        }
        catch (ex) {
            node = null;
        }
        return node;
    };
    
    w.__getLocation = function(e) {
        var loc = {x : 0, y : 0};
        while (e) {
            loc.x += e.offsetLeft;
            loc.y += e.offsetTop;
            e = e.offsetParent;
        }
        return loc;
    };

    // Allow caching regex objects for performance
    RegExp._cacheable = true;

    // Skip RegExp.test in String.quote to improve performance.
    String._quoteSkipTest = true;

    w.navigate = function(url) {
        window.setTimeout('window.location = "' + url + '";', 0);
    };

    var attachEventProxy = function(eventName, eventHandler) {
        eventHandler._mozillaEventHandler = function(e) {
            window.event = e;
            eventHandler();
            if (!e.avoidReturn) {
                return e.returnValue;
            }
        };
        this.addEventListener(eventName.slice(2), eventHandler._mozillaEventHandler, false);
    };

    var detachEventProxy = function (eventName, eventHandler) {
        if (eventHandler._mozillaEventHandler) {
            var mozillaEventHandler = eventHandler._mozillaEventHandler;
            delete eventHandler._mozillaEventHandler;
            
            this.removeEventListener(eventName.slice(2), mozillaEventHandler, false);
        }
    };

    w.attachEvent = attachEventProxy;
    w.detachEvent = detachEventProxy;
    w.HTMLDocument.prototype.attachEvent = attachEventProxy;
    w.HTMLDocument.prototype.detachEvent = detachEventProxy;
    w.HTMLElement.prototype.attachEvent = attachEventProxy;
    w.HTMLElement.prototype.detachEvent = detachEventProxy;

    w.Event.prototype.__defineGetter__('srcElement', function() {
        // __getNonTextNode(this.target) is the expected implementation.
        // However script.load has target set to the Document object... so we
        // need to throw in currentTarget as well.
        return __getNonTextNode(this.target) || this.currentTarget;
    });
    w.Event.prototype.__defineGetter__('cancelBubble', function() {
        return this._bubblingCanceled || false;
    });
    w.Event.prototype.__defineSetter__('cancelBubble', function(v) {
        if (v) {
            this._bubblingCanceled = true;
            this.stopPropagation();
        }
    });
    w.Event.prototype.__defineGetter__('returnValue', function() {
        return !this._cancelDefault;
    });
    w.Event.prototype.__defineSetter__('returnValue', function(v) {
        if (!v) {
            this._cancelDefault = true;
            this.preventDefault();
        }
    });
    w.Event.prototype.__defineGetter__('fromElement', function () {
        var n;
        if (this.type == 'mouseover') {
            n = this.relatedTarget;
        }
        else if (this.type == 'mouseout') {
            n = this.target;
        }
        return __getNonTextNode(n);
    });
    w.Event.prototype.__defineGetter__('toElement', function () {
        var n;
        if (this.type == 'mouseout') {
            n = this.relatedTarget;
        }
        else if (this.type == 'mouseover') {
            n = this.target;
        }
        return __getNonTextNode(n);
    });
    w.Event.prototype.__defineGetter__('button', function() {
        return (this.which == 1) ? 1 : (this.which == 3) ? 2 : 0
    });
    w.Event.prototype.__defineGetter__('offsetX', function() {
        return window.pageXOffset + this.clientX - __getLocation(this.srcElement).x;
    });
    w.Event.prototype.__defineGetter__('offsetY', function() {
        return window.pageYOffset + this.clientY - __getLocation(this.srcElement).y;
    });

    w.HTMLElement.prototype.__defineGetter__('parentElement', function() {
        return this.parentNode;
    });
    w.HTMLElement.prototype.__defineGetter__('children', function() {
        var children = [];
        var childCount = this.childNodes.length;
        for (var i = 0; i < childCount; i++) {
            var childNode = this.childNodes[i];
            if (childNode.nodeType == 1) {
                children.push(childNode);
            }
        }
        return children;
    });
    w.HTMLElement.prototype.__defineGetter__('innerText', function() {    
        try {
            return this.textContent
        } 
        catch (ex) {
            var text = '';
            for (var i=0; i < this.childNodes.length; i++) {
                if (this.childNodes[i].nodeType == 3) {
                    text += this.childNodes[i].textContent;
                }
            }
            return str;
        }
    });
    w.HTMLElement.prototype.__defineSetter__('innerText', function(v) {
        var textNode = document.createTextNode(v);
        this.innerHTML = '';
        this.appendChild(textNode);
    });
    w.HTMLElement.prototype.__defineGetter__('currentStyle', function() {
        return window.getComputedStyle(this, null);
    });
    w.HTMLElement.prototype.__defineGetter__('runtimeStyle', function() {
        return window.getOverrideStyle(this, null);
    });
    w.HTMLElement.prototype.removeNode = function(b) {
        return this.parentNode.removeChild(this)
    };
    w.HTMLElement.prototype.contains = function(el) {
        while (el != null && el != this) {
            el = el.parentNode;
        }
        return (el!=null)
    };

    w.HTMLStyleElement.prototype.__defineGetter__('styleSheet', function() {
        return this.sheet;
    });
    w.CSSStyleSheet.prototype.__defineGetter__('rules', function() {
        return this.cssRules;
    });
    w.CSSStyleSheet.prototype.addRule = function(selector, style, index) {
        this.insertRule(selector + '{' + style + '}', index);
    };
    w.CSSStyleSheet.prototype.removeRule = function(index) {
        this.deleteRule(index);
    };
    w.CSSStyleDeclaration.prototype.__defineGetter__('styleFloat', function() {
        return this.cssFloat;
    });
    w.CSSStyleDeclaration.prototype.__defineSetter__('styleFloat', function(v) {
        this.cssFloat = v;
    });
    DocumentFragment.prototype.getElementById = function(id) {
        var nodeQueue = [];
        var childNodes = this.childNodes;
        var node;
        var c;
        
        for (c = 0; c < childNodes.length; c++) {
            node = childNodes[c];
            if (node.nodeType == 1) {
                nodeQueue.push(node);
            }
        }

        while (nodeQueue.length) {
            node = nodeQueue.dequeue();
            if (node.id == id) {
                return node;
            }
            childNodes = node.childNodes;
            if (childNodes.length != 0) {
                for (c = 0; c < childNodes.length; c++) {
                    node = childNodes[c];
                    if (node.nodeType == 1) {
                        nodeQueue.push(node);
                    }
                }
            }
        }

        return null;
    };

    DocumentFragment.prototype.getElementsByTagName = function(tagName) {
        var elements = [];
        var nodeQueue = [];
        var childNodes = this.childNodes;
        var node;
        var c;

        for (c = 0; c < childNodes.length; c++) {
            node = childNodes[c];
            if (node.nodeType == 1) {
                nodeQueue.push(node);
            }
        }

        while (nodeQueue.length) {
            node = nodeQueue.dequeue();
            if (node.tagName == tagName) {
                elements.add(node);
            }
            childNodes = node.childNodes;
            if (childNodes.length != 0) {
                for (c = 0; c < childNodes.length; c++) {
                    node = childNodes[c];
                    if (node.nodeType == 1) {
                        nodeQueue.push(node);
                    }
                }
            }
        }

        return elements;
    };

    DocumentFragment.prototype.createElement = function(tagName) {
        return document.createElement(tagName);
    };

    var selectNodes = function(doc, path, contextNode) {
        contextNode = contextNode ? contextNode : doc;
        var xpath = new XPathEvaluator();
        var result = xpath.evaluate(path, contextNode,
                                    doc.createNSResolver(doc.documentElement),
                                    XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);

        var nodeList = new Array(result.snapshotLength);
        for(var i = 0; i < result.snapshotLength; i++) {
            nodeList[i] = result.snapshotItem(i);
        }

        return nodeList;
    };

    var selectSingleNode = function(doc, path, contextNode) {
        path += '[1]';
        var nodes = selectNodes(doc, path, contextNode);
        if (nodes.length != 0) {
            for (var i = 0; i < nodes.length; i++) {
                if (nodes[i]) {
                    return nodes[i];
                }
            }
        }
        return null;
    };

    w.XMLDocument.prototype.selectNodes = function(path, contextNode) {
        return selectNodes(this, path, contextNode);
    };

    w.XMLDocument.prototype.selectSingleNode = function(path, contextNode) {
        return selectSingleNode(this, path, contextNode);
    };

    w.XMLDocument.prototype.transformNode = function(xsl) {
        var xslProcessor = new XSLTProcessor();
        xslProcessor.importStylesheet(xsl);

        var ownerDocument = document.implementation.createDocument("", "", null);
        var transformedDoc = xslProcessor.transformToDocument(this);
        
        return transformedDoc.xml;
    };

    Node.prototype.selectNodes = function(path) {
        var doc = this.ownerDocument;
        return doc.selectNodes(path, this);
    };

    Node.prototype.selectSingleNode = function(path) {
        var doc = this.ownerDocument;
        return doc.selectSingleNode(path, this);
    };

    Node.prototype.__defineGetter__('baseName', function() {
        return this.localName;
    });

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

    Node.prototype.__defineGetter__('xml', function() {
        return (new XMLSerializer()).serializeToString(this);
    });
}

function __supportsCompatLayer(ua) {
    // Supported browsers:
    //  - Firefox 1.5+
    //  - WebKit 500+
    //  - Opera 9.5+
    return (ua.indexOf('Gecko') >= 0) || (ua.indexOf('AppleWebKit') >= 0) || (ua.indexOf('Opera') >= 0);
}

if (__supportsCompatLayer(window.navigator.userAgent)) {
    try {
        __loadCompatLayer(window);
    }
    catch (e) {
    }
}
//! Script# Core Runtime
//! Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
//! http://projects.nikhilk.net
//!

///////////////////////////////////////////////////////////////////////////////
// Globals

function isUndefined(o) {
    return (o === undefined);
}

function isNull(o) {
    return (o === null);
}

function isNullOrUndefined(o) {
    return (o === null) || (o === undefined);
}

window.__scriptsharp = '0.5.1.0';

function $(id) {
    return document.getElementById(id);
}

document.getElementsBySelector = function getElementsBySelector(cssSelector, root) {
    var all = root ? root.getElementsByTagName('*') : document.getElementsByTagName('*');
    var matches = [];

    // Create a stylesheet we'll use to insert a CSS rule into to do the matching.
    // This is created just once.
    var styleSheet = document.getElementsBySelector.styleSheet;
    if (!styleSheet) {
        var styleSheetNode = document.createElement('style');
        styleSheetNode.type = 'text/css';

        document.getElementsByTagName('head')[0].appendChild(styleSheetNode);
        styleSheet = styleSheetNode.styleSheet || styleSheetNode.sheet;
        
        document.getElementsBySelector.styleSheet = styleSheet;
    }

    if (window.navigator.userAgent.indexOf('MSIE') >= 0) {
        // Add the rule that will be used to match elements
        styleSheet.addRule(cssSelector, 'ssCssMatch:true', 0);

        for (var i = all.length - 1; i >= 0; i--) {
            var element = all[i];

            // Find elements that contain the special css attribute, i.e.
            // the elements that match the specified selector.
            if (element.currentStyle.ssCssMatch) {
                matches[matches.length] = element;
            }
        }

        styleSheet.removeRule(0);
    }
    else {
        var matchValue = document.getElementsBySelector.matchValue;
        if (!matchValue) {
            matchValue = (window.navigator.userAgent.indexOf('Opera') >= 0) ? '"ssCssMatch"' : 'ssCssMatch 1';
            document.getElementsBySelector.matchValue = matchValue;
        }

        // Add the rule that will be used to match elements
        styleSheet.insertRule(cssSelector + ' { counter-increment: ssCssMatch }', 0);

        var docView = document.defaultView;
        for (var i = all.length - 1; i >= 0; i--) {
            var element = all[i];

            // Find elements that contain the special css attribute, i.e.
            // the elements that match the specified selector.
            if (docView.getComputedStyle(element, null).counterIncrement === matchValue) {
                matches[matches.length] = element;
            }
        }

        styleSheet.deleteRule(0);
    }

    if (matches.length > 1) {
        matches.reverse();
    }
    return matches;
}

///////////////////////////////////////////////////////////////////////////////
// Object Extensions

Object.__typeName = 'Object';
Object.__baseType = null;

Object.parse = function Object$parse(s) {
    return eval(s);
}

Object.getKeyCount = function Object$getKeyCount(d) {
    var count = 0;
    for (var n in d) {
        count++;
    }
    return count;
}

Object.clearKeys = function Object$clearKeys(d) {
    for (var n in d) {
        delete d[n];
    }
}

Object.keyExists = function Object$keyExists(d, key) {
    return d[key] !== undefined;
}

///////////////////////////////////////////////////////////////////////////////
// Function Extensions

Function.parse = function Function$parse(s) {
    if (!Function._parseCache) {
        Function._parseCache = { };
    }

    var fn = Function._parseCache[s];
    if (!fn) {
        try {
            eval('fn = ' + s);
            if (typeof(fn) != 'function') {
                fn = null;
            }
            else {
                Function._parseCache[s] = fn;
            }
        }
        catch (ex) {
        }
    }
    return fn;
}

Function.prototype.invoke = function Function$invoke() {
    this.apply(null, arguments);
}

///////////////////////////////////////////////////////////////////////////////
// Boolean Extensions

Boolean.__typeName = 'Boolean';

Boolean.parse = function Boolean$parse(s) {
    return (s.toLowerCase() == 'true');
}

///////////////////////////////////////////////////////////////////////////////
// Number Extensions

Number.__typeName = 'Number';

Number.parse = function Number$parse(s) {
    if (!s || !s.length) {
        return 0;
    }
    if ((s.indexOf('.') >= 0) || (s.indexOf('e') >= 0) ||
        s.endsWith('f') || s.endsWith('F')) {
        return parseFloat(s);
    }
    return parseInt(s, 10);
}

Number.prototype.format = function Number$format(format, useLocale) {
    if (isNullOrUndefined(format) ||
        (format.length == 0) || (format == 'i')) {
        if (useLocale) {
            return this.toLocaleString();
        }
        else {
            return this.toString();
        }
    }

    return this._netFormat(format, useLocale);
}

Number._commaFormat = function Number$_commaFormat(number, groups, decimal, comma) {
    var decimalPart = null;
    var decimalIndex = number.indexOf(decimal);
    if (decimalIndex > 0) {
        decimalPart = number.substr(decimalIndex);
        number = number.substr(0, decimalIndex);
    }

    var negative = number.startsWith('-');
    if (negative) {
        number = number.substr(1);
    }

    var groupIndex = 0;
    var groupSize = groups[groupIndex];
    if (number.length < groupSize) {
        return decimalPart ? number + decimalPart : number;
    }

    var index = number.length;
    var s = '';
    var done = false;
    while (!done) {
        var length = groupSize;
        var startIndex = index - length;
        if (startIndex < 0) {
            groupSize += startIndex;
            length += startIndex;
            startIndex = 0;
            done = true;
        }
        if (!length) {
            break;
        }
        
        var part = number.substr(startIndex, length);
        if (s.length) {
            s = part + comma + s;
        }
        else {
            s = part;
        }
        index -= length;

        if (groupIndex < groups.length - 1) {
            groupIndex++;
            groupSize = groups[groupIndex];
        }
    }

    if (negative) {
        s = '-' + s;
    }    
    return decimalPart ? s + decimalPart : s;
}

Number.prototype._netFormat = function Number$_netFormat(format, useLocale) {
    var nf = useLocale ? CultureInfo.Current.numberFormat : CultureInfo.Neutral.numberFormat;

    var s = '';    
    var precision = -1;
    
    if (format.length > 1) {
        precision = parseInt(format.substr(1));
    }

    var fs = format.charAt(0);
    switch (fs) {
        case 'd': case 'D':
            s = parseInt(Math.abs(this)).toString();
            if (precision != -1) {
                s = s.padLeft(precision, '0');
            }
            if (this < 0) {
                s = '-' + s;
            }
            break;
        case 'x': case 'X':
            s = parseInt(Math.abs(this)).toString(16);
            if (fs == 'X') {
                s = s.toUpperCase();
            }
            if (precision != -1) {
                s = s.padLeft(precision, '0');
            }
            break;
        case 'e': case 'E':
            if (precision == -1) {
                s = this.toExponential();
            }
            else {
                s = this.toExponential(precision);
            }
            if (fs == 'E') {
                s = s.toUpperCase();
            }
            break;
        case 'f': case 'F':
        case 'n': case 'N':
            if (precision == -1) {
                precision = nf.numberDecimalDigits;
            }
            s = this.toFixed(precision).toString();
            if (precision && (nf.numberDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.numberDecimalSeparator + s.substr(index + 1);
            }
            if ((fs == 'n') || (fs == 'N')) {
                s = Number._commaFormat(s, nf.numberGroupSizes, nf.numberDecimalSeparator, nf.numberGroupSeparator);
            }
            break;
        case 'c': case 'C':
            if (precision == -1) {
                precision = nf.currencyDecimalDigits;
            }
            s = Math.abs(this).toFixed(precision).toString();
            if (precision && (nf.currencyDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.currencyDecimalSeparator + s.substr(index + 1);
            }
            s = Number._commaFormat(s, nf.currencyGroupSizes, nf.currencyDecimalSeparator, nf.currencyGroupSeparator);
            if (this < 0) {
                s = String.format(nf.currencyNegativePattern, s);
            }
            else {
                s = String.format(nf.currencyPositivePattern, s);
            }
            break;
        case 'p': case 'P':
            if (precision == -1) {
                precision = nf.percentDecimalDigits;
            }
            s = (Math.abs(this) * 100.0).toFixed(precision).toString();
            if (precision && (nf.percentDecimalSeparator != '.')) {
                var index = s.indexOf('.');
                s = s.substr(0, index) + nf.percentDecimalSeparator + s.substr(index + 1);
            }
            s = Number._commaFormat(s, nf.percentGroupSizes, nf.percentDecimalSeparator, nf.percentGroupSeparator);
            if (this < 0) {
                s = String.format(nf.percentNegativePattern, s);
            }
            else {
                s = String.format(nf.percentPositivePattern, s);
            }
            break;
    }

    return s;
}

///////////////////////////////////////////////////////////////////////////////
// Math Extensions

Math.truncate = function Math$truncate(n) {
    return (n >= 0) ? Math.floor(n) : Math.ceil(n);
}

///////////////////////////////////////////////////////////////////////////////
// String Extensions

String.__typeName = 'String';
String.Empty = '';

String.compare = function String$compare(s1, s2, ignoreCase) {
    if (ignoreCase) {
        if (s1) {
            s1 = s1.toUpperCase();
        }
        if (s2) {
            s2 = s2.toUpperCase();
        }
    }
    s1 = s1 || '';
    s2 = s2 || '';

    if (s1 == s2) {
        return 0;
    }
    if (s1 < s2) {
        return -1;
    }
    return 1;
}

String.prototype.compareTo = function String$compareTo(s, ignoreCase) {
    return String.compare(this, s, ignoreCase);
}

String.prototype.endsWith = function String$endsWith(suffix) {
    if (!suffix.length) {
        return true;
    }
    if (suffix.length > this.length) {
        return false;
    }
    return (this.substr(this.length - suffix.length) == suffix);
}

String.equals = function String$equals1(s1, s2, ignoreCase) {
    return String.compare(s1, s2, ignoreCase) == 0;
}

String._format = function String$_format(format, values, useLocale) {
    if (!String._formatRE) {
        String._formatRE = /(\{[^\}^\{]+\})/g;
    }

    return format.replace(String._formatRE,
                          function(str, m) {
                              var index = parseInt(m.substr(1));
                              var value = values[index + 1];
                              if (isNullOrUndefined(value)) {
                                  return '';
                              }
                              if (value.format) {
                                  var formatSpec = null;
                                  var formatIndex = m.indexOf(':');
                                  if (formatIndex > 0) {
                                      formatSpec = m.substring(formatIndex + 1, m.length - 1);
                                  }
                                  return value.format.call(value, formatSpec, useLocale);
                              }
                              else {
                                  if (useLocale) {
                                      return value.toLocaleString();
                                  }
                                  return value.toString();
                              }
                          });
}

String.format = function String$format(format) {
    return String._format(format, arguments, /* useLocale */ false);
}

String.fromChar = function String$fromChar(ch, count) {
    var s = ch;
    for (var i = 1; i < count; i++) {
        s += ch;
    }
    return s;
}

String.prototype.htmlDecode = function String$htmlDecode() {
    if (!String._htmlDecRE) {
        String._htmlDecMap = { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"' };
        String._htmlDecRE = /(&amp;|&lt;|&gt;|&quot;)/gi;
    }

    var s = this;
    s = s.replace(String._htmlDecRE,
                  function String$htmlDecode$replace(str, m) {
                      return String._htmlDecMap[m];
                  });
    return s;
}

String.prototype.htmlEncode = function String$htmlEncode() {
    if (!String._htmlEncRE) {
        String._htmlEncMap = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' };
        String._htmlEncRE = /([&<>"])/g;
    }

    var s = this;
    if (String._htmlEncRE.test(s)) {
        s = s.replace(String._htmlEncRE,
                      function String$htmlEncode$replace(str, m) {
                          return String._htmlEncMap[m];
                      });
    }
    return s;
}

String.prototype.indexOfAny = function String$indexOfAny(chars, startIndex, count) {
    var length = this.length;
    if (!length) {
        return -1;
    }

    startIndex = startIndex || 0;
    count = count || length;

    var endIndex = startIndex + count - 1;
    if (endIndex >= length) {
        endIndex = length - 1;
    }

    for (var i = startIndex; i <= endIndex; i++) {
        if (chars.indexOf(this.charAt(i)) >= 0) {
            return i;
        }
    }
    return -1;
}

String.prototype.insert = function String$insert(index, value) {
    if (!value) {
        return this;
    }
    if (!index) {
        return value + this;
    }
    var s1 = this.substr(0, index);
    var s2 = this.substr(index);
    return s1 + value + s2;
}

String.isNullOrEmpty = function String$isNullOrEmpty(s) {
    return !s || !s.length;
}

String.prototype.lastIndexOfAny = function String$lastIndexOfAny(chars, startIndex, count) {
    var length = this.length;
    if (!length) {
        return -1;
    }

    startIndex = startIndex || length - 1;
    count = count || length;

    var endIndex = startIndex - count + 1;
    if (endIndex < 0) {
        endIndex = 0;
    }

    for (var i = startIndex; i >= endIndex; i--) {
        if (chars.indexOf(this.charAt(i)) >= 0) {
            return i;
        }
    }
    return -1;
}

String.localeFormat = function String$localeFormat(format) {
    return String._format(format, arguments, /* useLocale */ true);
}

String.prototype.padLeft = function String$padLeft(totalWidth, ch) {
    if (this.length < totalWidth) {
        ch = ch || ' ';
        return String.fromChar(ch, totalWidth - this.length) + this;
    }
    return this;
}

String.prototype.padRight = function String$padRight(totalWidth, ch) {
    if (this.length < totalWidth) {
        ch = ch || ' ';
        return this + String.fromChar(ch, totalWidth - this.length);
    }
    return this;
}

String.prototype.quote = function String$quote() {
    if (!String._quoteMap) {
        String._quoteMap = { '\\' : '\\\\',
                             '\'' : '\\\'', '"' : '\\"',
                             '\r' : '\\r', '\n' : '\\n', '\t' : '\\t', '\f' : '\\f',
                             '\b' : '\\b' };
    }
    if (!String._quoteRE || !RegExp._cacheable) {
        String._quoteRE = new RegExp("([\'\"\\\\\x00-\x1F\x7F-\uFFFF])", "g");
    }

    var s = this;
    if (String._quoteSkipTest || String._quoteRE.test(s)) {
        s = this.replace(String._quoteRE,
                         function String$quote$replace(str, m) {
                             var c = String._quoteMap[m];
                             if (c) {
                                 return c;
                             }
                             c = m.charCodeAt(0);
                             return '\\u' + c.toString(16).toUpperCase().padLeft(4, '0');
                         });
    }
    return '"' + s + '"';
}

String.prototype.remove = function String$remove(index, count) {
    if (!count || ((index + count) > this.length)) {
        return this.substr(0, index);
    }
    return this.substr(0, index) + this.substr(index + count);
}

String.prototype._replace = String.prototype.replace;
String.prototype.replace = function String$replace(oldValue, newValue) {
    if (oldValue.constructor == String) {
        newValue = newValue || '';
        return this.split(oldValue).join(newValue);
    }
    return String.prototype._replace.call(this, oldValue, newValue);
}

String.prototype.startsWith = function String$startsWith(prefix) {
    if (!prefix.length) {
        return true;
    }
    if (prefix.length > this.length) {
        return false;
    }
    return (this.substr(0, prefix.length) == prefix);
}

String.prototype.trim = function String$trim() {
    return this.trimEnd().trimStart();
}

String.prototype.trimEnd = function String$trimEnd() {
    return this.replace(/\s*$/, '');
}

String.prototype.trimStart = function String$trimStart() {
    return this.replace(/^\s*/, '');
}

String.prototype.unquote = function String$unquote() {
    return eval('(' + this + ')');
}

///////////////////////////////////////////////////////////////////////////////
// Array Extensions

Array.__typeName = 'Array';

Array.prototype.add = function Array$add(item) {
    this[this.length] = item;
}

Array.prototype.addRange = function Array$addRange(items) {
    if (!items) {
        return;
    }
    var length = items.length;
    for (var index = 0; index < length; index++) {
        this[this.length] = items[index];
    }
}

Array.prototype.aggregate = function Array$aggregate(seed, callback) {
    var length = this.length;
    for (var index = 0; index < length; index++) {
        seed = callback(seed, this[index], index, this);
    }
    return seed;
}

Array.prototype.clear = function Array$clear() {
    if (this.length > 0) {
        this.splice(0, this.length);
    }
}

Array.prototype.clone = function Array$clone() {
    var length = this.length;
    var array = new Array(length);
    for (var index = 0; index < length; index++) {
        array[index] = this[index];
    }
    return array;
}

Array.prototype.contains = function Array$contains(item) {
    var index = this.indexOf(item);
    return (index >= 0);
}

Array.prototype.dequeue = function Array$dequeue() {
    return this.shift();
}

Array.prototype.enqueue = function Array$enqueue(item) {
    // We record that this array instance is a queue, so we
    // can implement the right behavior in the peek method.
    this._queue = true;
    this.push(item);
}

Array.prototype.peek = function Array$peek() {
    if (this.length) {
        var index = this._queue ? 0 : this.length - 1;
        return this[index];
    }
    return null;
}

if (!Array.prototype.every) {
    Array.prototype.every = function Array$every(callback) {
        for (var i = this.length - 1; i >= 0; i--) {
            if (!callback(this[i], i, this)) {
                return false;
            }
        }
        return true;
    }
}

Array.prototype.extract = function Array$extract(index, count) {
    if (!count) {
        return this.slice(index);
    }
    return this.slice(index, index + count);
}

if (!Array.prototype.filter) {
    Array.prototype.filter = function Array$filter(callback) {
        var filtered = [];
        for (var i = 0; i < this.length; i++) {
            if (callback(this[i], i, this)) {
                filtered.add(this[i]);
            }
        }
        return filtered;
    }
}

if (!Array.prototype.forEach) {
    Array.prototype.forEach = function Array$forEach(callback) {
        for (var i = 0; i < this.length; i++) {
            callback(this[i], i, this);
        }
    }
}

Array.prototype.groupBy = function Array$groupBy(callback) {
    var length = this.length;
    var groups = [];
    var keys = { };
    for (var index = 0; index < length; index++) {
        var key = callback(this[index], index);
        if (String.isNullOrEmpty(key)) {
            continue;
        }
        var items = keys[key];
        if (!items) {
            items = [];
            items.key = key;

            keys[key] = items;
            groups.add(items);
        }
        items.add(this[index]);
    }
    return groups;
}

Array.prototype.index = function Array$index(callback) {
    var length = this.length;
    var items = { };
    for (var index = 0; index < length; index++) {
        var key = callback(this[index], index);
        if (String.isNullOrEmpty(key)) {
            continue;
        }
        items[key] = this[index];
    }
    return items;
}

Array.prototype.indexOf = function Array$indexOf(item) {
    var length = this.length;
    if (length) {
        for (var index = 0; index < length; index++) {
            if (this[index] === item) {
                return index;
            }
        }
    }
    return -1;
}

Array.prototype.insert = function Array$insert(index, item) {
    this.splice(index, 0, item);
}

Array.prototype.insertRange = function Array$insertRange(index, items) {
    this.splice(index, 0, items);
}

if (!Array.prototype.map) {
    Array.prototype.map = function Array$map(callback) {
        var mapped = new Array(this.length);
        for (var i = this.length - 1; i >= 0; i--) {
            mapped[i] = callback(this[i], i, this);
        }
        return mapped;
    }
}

Array.parse = function Array$parse(s) {
    return eval('(' + s + ')');
}

Array.prototype.remove = function Array$remove(item) {
    var index = this.indexOf(item);
    if (index >= 0) {
        this.splice(index, 1);
        return true;
    }
    return false;
}

Array.prototype.removeAt = function Array$removeAt(index) {
    return this.splice(index, 1)[0];
}

Array.prototype.removeRange = function Array$removeRange(index, count) {
    return this.splice(index, count);
}

if (!Array.prototype.some) {
    Array.prototype.some = function Array$some(callback) {
        for (var i = this.length - 1; i >= 0; i--) {
            if (callback(this[i], i, this)) {
                return true;
            }
        }
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////
// RegExp Extensions

RegExp.__typeName = 'RegExp';

RegExp.parse = function RegExp$parse(s) {
    if (s.startsWith('/')) {
        var endSlashIndex = s.lastIndexOf('/');
        if (endSlashIndex > 1) {
            var expression = s.substring(1, endSlashIndex);
            var flags = s.substr(endSlashIndex + 1);
            return new RegExp(expression, flags);
        }
    }

    return null;    
}

///////////////////////////////////////////////////////////////////////////////
// Date Extensions

Date.__typeName = 'Date';

Date.get_now = function Date$get_now() {
    return new Date();
}

Date.get_today = function Date$get_today() {
    var d = new Date();
    return new Date(d.getFullYear(), d.getMonth(), d.getDate());
}

Date.prototype.format = function Date$format(format, useLocale) {
    if (isNullOrUndefined(format) ||
        (format.length == 0) || (format == 'i')) {
        if (useLocale) {
            return this.toLocaleString();
        }
        else {
            return this.toString();
        }
    }
    if (format == 'id') {
        if (useLocale) {
            return this.toLocaleDateString();
        }
        else {
            return this.toDateString();
        }
    }
    if (format == 'it') {
        if (useLocale) {
            return this.toLocaleTimeString();
        }
        else {
            return this.toTimeString();
        }
    }

    return this._netFormat(format, useLocale);
}

Date.prototype._netFormat = function Date$_netFormat(format, useLocale) {
    var dtf = useLocale ? CultureInfo.Current.dateFormat : CultureInfo.Neutral.dateFormat;
    var useUTC = false;

    if (format.length == 1) {
        switch (format) {
            case 'f': format = dtf.longDatePattern + ' ' + dtf.shortTimePattern;
            case 'F': format = dtf.dateTimePattern; break;

            case 'd': format = dtf.shortDatePattern; break;
            case 'D': format = dtf.longDatePattern; break;

            case 't': format = dtf.shortTimePattern; break;
            case 'T': format = dtf.longTimePattern; break;

            case 'g': format = dtf.shortDatePattern + ' ' + dtf.shortTimePattern; break;
            case 'G': format = dtf.shortDatePattern + ' ' + dtf.longTimePattern; break;

            case 'R': case 'r': format = dtf.gmtDateTimePattern; useUTC = true; break;
            case 'u': format = dtf.universalDateTimePattern; useUTC = true; break;
            case 'U': format = dtf.dateTimePattern; useUTC = true; break;

            case 's': format = dtf.sortableDateTimePattern; break;
        }
    }

    if (format.charAt(0) == '%') {
        format = format.substr(1);
    }

    if (!Date._formatRE) {
        Date._formatRE = /dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|y|hh|h|HH|H|mm|m|ss|s|tt|t|fff|ff|f|zzz|zz|z/g;
    }

    var re = Date._formatRE;    
    var sb = new StringBuilder();
    var dt = this;
    if (useUTC) {
        dt = new Date(Date.UTC(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate(),
                               dt.getUTCHours(), dt.getUTCMinutes(), dt.getUTCSeconds(), dt.getUTCMilliseconds()));
    }

    re.lastIndex = 0;
    while (true) {
        var index = re.lastIndex;
        var match = re.exec(format);

        sb.append(format.slice(index, match ? match.index : format.length));
        if (!match) {
            break;
        }

        var fs = match[0];
        var part = fs;
        switch (fs) {
            case 'dddd':
                part = dtf.dayNames[dt.getDay()];
                break;
            case 'ddd':
                part = dtf.shortDayNames[dt.getDay()];
                break;
            case 'dd':
                part = dt.getDate().toString().padLeft(2, '0');
                break;
            case 'd':
                part = dt.getDate();
                break;
            case 'MMMM':
                part = dtf.monthNames[dt.getMonth()];
                break;
            case 'MMM':
                part = dtf.shortMonthNames[dt.getMonth()];
                break;
            case 'MM':
                part = (dt.getMonth() + 1).toString().padLeft(2, '0');
                break;
            case 'M':
                part = (dt.getMonth() + 1);
                break;
            case 'yyyy':
                part = dt.getFullYear();
                break;
            case 'yy':
                part = (dt.getFullYear() % 100).toString().padLeft(2, '0');
                break;
            case 'y':
                part = (dt.getFullYear() % 100);
                break;
            case 'h': case 'hh':
                part = dt.getHours() % 12;
                if (!part) {
                    part = '12';
                }
                else if (fs == 'hh') {
                    part = part.toString().padLeft(2, '0');
                }
                break;
            case 'HH':
                part = dt.getHours().toString().padLeft(2, '0');
                break;
            case 'H':
                part = dt.getHours();
                break;
            case 'mm':
                part = dt.getMinutes().toString().padLeft(2, '0');
                break;
            case 'm':
                part = dt.getMinutes();
                break;
            case 'ss':
                part = dt.getSeconds().toString().padLeft(2, '0');
                break;
            case 's':
                part = dt.getSeconds();
                break;
            case 't': case 'tt':
                part = (dt.getHours() < 12) ? dtf.amDesignator : dtf.pmDesignator;
                if (fs == 't') {
                    part = part.charAt(0);
                }
                break;
            case 'fff':
                part = dt.getMilliseconds().toString().padLeft(3, '0');
                break;
            case 'ff':
                part = dt.getMilliseconds().toString().padLeft(3).substr(0, 2);
                break;
            case 'f':
                part = dt.getMilliseconds().toString().padLeft(3).charAt(0);
                break;
            case 'z':
                part = dt.getTimezoneOffset() / 60;
                part = ((part >= 0) ? '-' : '+') + Math.floor(Math.abs(part));
                break;
            case 'zz': case 'zzz':
                part = dt.getTimezoneOffset() / 60;
                part = ((part >= 0) ? '-' : '+') + Math.floor(Math.abs(part)).toString().padLeft(2, '0');
                if (fs == 'zzz') {
                    part += dtf.timeSeparator + Math.abs(dt.getTimezoneOffset() % 60).toString().padLeft(2, '0');
                }
                break;
        }
        sb.append(part);
    }

    return sb.toString();
}

Date._parse = Date.parse;
Date.parse = function Date$parse(s) {
    // Date.parse by default returns the number of milliseconds
    // and not an actual Date instance
    return new Date(Date._parse(s));
}

///////////////////////////////////////////////////////////////////////////////
// Error Extensions

Error.__typeName = 'Error';

Error.create = function Error$create(message, userData, innerException) {
    var e = new Error(message);
    if (userData) {
        e.userData = userData;
    }
    if (innerException) {
        e.innerException = innerException;
    }
    return e;
}

///////////////////////////////////////////////////////////////////////////////
// Debug Extensions

if (!Debug._fail) {
    Debug._fail = function Debug$_fail(message) {
        Debug.writeln(message);
        eval('debugger;');
    }
}

Debug.assert = function Debug$assert(condition, message) {
    if (!condition) {
        message = 'Assert failed: ' + message;
        if (confirm(message + '\r\n\r\nBreak into debugger?')) {
            Debug._fail(message);
        }
    }
}

Debug._dumpCore = function Debug$_dumpCore(sb, object, name, indentation, dumpedObjects) {
    if (object === null) {
        sb.appendLine(indentation + name + ': null');
        return;
    }
    switch (typeof(object)) {
        case 'undefined':
            sb.appendLine(indentation + name + ': undefined');
            break;
        case 'number':
        case 'string':
        case 'boolean':
            sb.appendLine(indentation + name + ': ' + object);
            break;
        default:
            if (Date.isInstance(object) || RegExp.isInstance(object)) {
                sb.appendLine(indentation + name + ': ' + object);
                break;
            }

            if (dumpedObjects.contains(object)) {
                sb.appendLine(indentation + name + ': ...');
                break;
            }
            dumpedObjects.add(object);

            var type = Type.getInstanceType(object);
            var typeName = type.get_fullName();
            var recursiveIndentation = indentation + '  ';

            if (IArray.isInstance(object)) {
                sb.appendLine(indentation + name + ': {' + typeName + '}');
                var length = object.getLength();
                for (var i = 0; i < length; i++) {
                    Debug._dumpCore(sb, object.getItem(i), '[' + i + ']', recursiveIndentation, dumpedObjects);
                }
            }
            else {
                if (object.tagName) {
                    sb.appendLine(indentation + name + ': <' + object.tagName + '>');
                    var attributes = object.attributes;
                    for (var i = 0; i < attributes.length; i++) {
                        var attrValue = attributes[i].nodeValue;
                        if (attrValue) {
                            Debug._dumpCore(sb, attrValue, attributes[i].nodeName, recursiveIndentation, dumpedObjects);
                        }
                    }
                }
                else {
                    sb.appendLine(indentation + name + ': {' + typeName + '}');
                    for (var field in object) {
                        var v = object[field];
                        if (!Function.isInstance(v)) {
                            Debug._dumpCore(sb, v, field, recursiveIndentation, dumpedObjects);
                        }
                    }
                }
            }

            dumpedObjects.remove(object);
            break;
    }
}

Debug.dump = function Debug$dump(object, name) {
    if ((!name || !name.length) && (object !== null)) {
        name = Type.getInstanceType(object).get_fullName();
    }
    if (!name || !name.length) {
        return;
    }
    var sb = new StringBuilder();
    Debug._dumpCore(sb, object, name, '', []);
    Debug.writeLine(sb.toString());
}

Debug.fail = function Debug$fail(message) {
    Debug._fail(message);
}

Debug.inspect = function Debug$inspect(object, name) {
    var dumped = false;
    if (window.debugService) {
        dumped = window.debugService.inspect(name, object);
    }
    if (!dumped) {
        Debug.dump(object, name);
    }
}

Debug.writeLine = function Debug$writeLine(message) {
    if (window.debugService) {
        window.debugService.trace(message);
        return;
    }
    Debug.writeln(message);

    var traceTextBox = $('_traceTextBox');
    if (traceTextBox) {
        traceTextBox.value = traceTextBox.value + '\r\n' + message;
    }
}

Debug.__typeName = 'Debug';

///////////////////////////////////////////////////////////////////////////////
// Type System Implementation

var Type = Function;
Type.__typeName = 'Type';

var __Namespace = function(name) {
    this.__typeName = name;
}
__Namespace.prototype = {
    __namespace: true,
    getName: function() {
        return this.__typeName;
    }
}

Type.createNamespace = function Type$createNamespace(name) {
    if (!window.__namespaces) {
        window.__namespaces = {};
    }
    if (!window.__rootNamespaces) {
        window.__rootNamespaces = [];
    }

    if (window.__namespaces[name]) {
        return;
    }

    var ns = window;
    var nameParts = name.split('.');

    for (var i = 0; i < nameParts.length; i++) {
        var part = nameParts[i];
        var nso = ns[part];
        if (!nso) {
            ns[part] = nso = new __Namespace(nameParts.slice(0, i + 1).join('.'));
            if (i == 0) {
                window.__rootNamespaces.add(nso);
            }
        }
        ns = nso;
    }

    window.__namespaces[name] = ns;
}

Type.prototype.createClass = function Type$createClass(name, baseType, interfaceType) {
    this.prototype.constructor = this;
    this.__typeName = name;
    this.__class = true;
    this.__baseType = baseType || Object;
    if (baseType) {
        this.__basePrototypePending = true;
    }

    if (interfaceType) {
        this.__interfaces = [];
        for (var i = 2; i < arguments.length; i++) {
            interfaceType = arguments[i];
            this.__interfaces.add(interfaceType);
        }
    }
}

Type.prototype.createInterface = function Type$createInterface(name) {
    this.__typeName = name;
    this.__interface = true;
}

Type.prototype.createEnum = function Type$createEnum(name, flags) {
    for (var field in this.prototype) {
         this[field] = this.prototype[field];
    }

    this.__typeName = name;
    this.__enum = true;
    if (flags) {
        this.__flags = true;
    }
}

Type.prototype.setupBase = function Type$setupBase() {
    if (this.__basePrototypePending) {
        var baseType = this.__baseType;
        if (baseType.__basePrototypePending) {
            baseType.setupBase();
        }

        for (var memberName in baseType.prototype) {
            var memberValue = baseType.prototype[memberName];
            if (!this.prototype[memberName]) {
                this.prototype[memberName] = memberValue;
            }
        }

        delete this.__basePrototypePending;
    }
}

if (!Type.prototype.resolveInheritance) {
    // This function is not used by Script#; Visual Studio relies on it
    // for JavaScript IntelliSense support of derived types.
    Type.prototype.resolveInheritance = Type.prototype.setupBase;
}

Type.prototype.constructBase = function Type$constructBase(instance, args) {
    if (this.__basePrototypePending) {
        this.setupBase();
    }

    if (!args) {
        this.__baseType.apply(instance);
    }
    else {
        this.__baseType.apply(instance, args);
    }
}

Type.prototype.callBase = function Type$callBase(instance, name, args) {
    var baseMethod = this.__baseType.prototype[name];
    if (!args) {
        return baseMethod.apply(instance);
    }
    else {
        return baseMethod.apply(instance, args);
    }
}

Type.prototype.get_baseType = function Type$get_baseType() {
    return this.__baseType || null;
}

Type.prototype.get_fullName = function Type$get_fullName() {
    return this.__typeName;
}

Type.prototype.get_name = function Type$get_name() {
    var fullName = this.__typeName;
    var nsIndex = fullName.lastIndexOf('.');
    if (nsIndex > 0) {
        return fullName.substr(nsIndex + 1);
    }
    return fullName;
}

Type.prototype.isInstance = function Type$isInstance(instance) {
    if (isNullOrUndefined(instance)) {
        return false;
    }
    if ((this == Object) || (instance instanceof this)) {
        return true;
    }

    var type = Type.getInstanceType(instance);
    return this.isAssignableFrom(type);
}

Type.prototype.isAssignableFrom = function Type$isAssignableFrom(type) {
    if ((this == Object) || (this == type)) {
        return true;
    }
    if (this.__class) {
        var baseType = type.__baseType;
        while (baseType) {
            if (this == baseType) {
                return true;
            }
            baseType = baseType.__baseType;
        }
    }
    else if (this.__interface) {
        var interfaces = type.__interfaces;
        if (interfaces && interfaces.contains(this)) {
            return true;
        }

        var baseType = type.__baseType;
        while (baseType) {
            interfaces = baseType.__interfaces;
            if (interfaces && interfaces.contains(this)) {
                return true;
            }
            baseType = baseType.__baseType;
        }
    }
    return false;
}

Type.isClass = function Type$isClass(type) {
    return (type.__class == true);
}

Type.isEnum = function Type$isEnum(type) {
    return (type.__enum == true);
}

Type.isFlagsEnum = function Type$isFlagsEnum(type) {
    return ((type.__enum == true) && (type.__flags == true));
}

Type.isInterface = function Type$isInterface(type) {
    return (type.__interface == true);
}

Type.canCast = function Type$canCast(instance, type) {
    return type.isInstance(instance);
}

Type.safeCast = function Type$safeCast(instance, type) {
    if (type.isInstance(instance)) {
        return instance;
    }
    return null;
}

Type.getInstanceType = function Type$getInstanceType(instance) {
    var ctor = null;

    // NOTE: We have to catch exceptions because the constructor
    //       cannot be looked up on native COM objects
    try {
        ctor = instance.constructor;
    }
    catch (ex) {
    }
    if (!ctor || !ctor.__typeName) {
        ctor = Object;
    }
    return ctor;
}

Type.getType = function Type$getType(typeName) {
    if (!typeName) {
        return null;
    }

    if (!Type.__typeCache) {
        Type.__typeCache = {};
    }

    var type = Type.__typeCache[typeName];
    if (!type) {
        type = eval(typeName);
        Type.__typeCache[typeName] = type;
    }
    return type;
}

Type.parse = function Type$parse(typeName) {
    return Type.getType(typeName);
}

///////////////////////////////////////////////////////////////////////////////
// Enum

var Enum = function() {
}
Enum.createClass('Enum');

Enum.parse = function Enum$parse(enumType, s) {
    var values = enumType.prototype;
    if (!enumType.__flags) {
        for (var f in values) {
            if (f === s) {
                return values[f];
            }
        }
    }
    else {
        var parts = s.split('|');
        var value = 0;
        var parsed = true;

        for (var i = parts.length - 1; i >= 0; i--) {
            var part = parts[i].trim();
            var found = false;

            for (var f in values) {
                if (f === part) {
                    value |= values[f];
                    found = true;
                    break;
                }
            }
            if (!found) {
                parsed = false;
                break;
            }
        }

        if (parsed) {
            return value;
        }
    }
    throw 'Invalid Enumeration Value';
}

Enum.toString = function Enum$toString(enumType, value) {
    var values = enumType.prototype;
    if (!enumType.__flags || (value === 0)) {
        for (var i in values) {
            if (values[i] === value) {
                return i;
            }
        }
        throw 'Invalid Enumeration Value';
    }
    else {
        var parts = [];
        for (var i in values) {
            if (values[i] & value) {
                if (parts.length) {
                    parts.add(' | ');
                }
                parts.add(i);
            }
        }
        if (!parts.length) {
            throw 'Invalid Enumeration Value';
        }
        return parts.join('');
    }
}

///////////////////////////////////////////////////////////////////////////////
// Delegate

var Delegate = function() {
}
Delegate.createClass('Delegate');

Delegate.Null = function() { }

Delegate._create = function Delegate$_create(targets) {
    var delegate = function() {
        if (targets.length == 2) {
            return targets[1].apply(targets[0], arguments);
        }
        else {
            for (var i = 0; i < targets.length; i += 2) {
                targets[i + 1].apply(targets[i], arguments);
            }
            return null;
        }
    };
    delegate.invoke = delegate;
    delegate._targets = targets;

    return delegate;
}

Delegate.create = function Delegate$create(object, method) {
    if (!object) {
        method.invoke = method;
        return method;
    }
    return Delegate._create([object, method]);
}

Delegate.combine = function Delegate$combine(delegate1, delegate2) {
    if (!delegate1) {
        if (!delegate2._targets) {
            return Delegate.create(null, delegate2);
        }
        return delegate2;
    }
    if (!delegate2) {
        if (!delegate1._targets) {
            return Delegate.create(null, delegate1);
        }
        return delegate1;
    }

    var targets1 = delegate1._targets ? delegate1._targets : [null, delegate1];
    var targets2 = delegate2._targets ? delegate2._targets : [null, delegate2];

    return Delegate._create(targets1.concat(targets2));
}

Delegate.remove = function Delegate$remove(delegate1, delegate2) {
    if (!delegate1 || (delegate1 === delegate2)) {
        return null;
    }
    if (!delegate2) {
        return delegate1;
    }

    var targets = delegate1._targets;
    var object = null;
    var method;
    if (delegate2._targets) {
        object = delegate2._targets[0];
        method = delegate2._targets[1];
    }
    else {
        method = delegate2;
    }

    for (var i = 0; i < targets.length; i += 2) {
        if ((targets[i] === object) && (targets[i + 1] === method)) {
            if (targets.length == 2) {
                return null;
            }
            targets.splice(i, 2);
            return Delegate._create(targets);
        }
    }

    return delegate1;
}


Delegate.createExport = function Delegate$createExport(delegate, multiUse) {
    var name = '__' + (new Date()).valueOf();
    Delegate[name] = function() {
        if (!multiUse) {
            Delegate.deleteExport(name);
        }
        delegate.apply(null, arguments);
    };

    return name;
}

Delegate.deleteExport = function Delegate$deleteExport(name) {
    if (Delegate[name]) {
        delete Delegate[name];
    }
}

Delegate.clearExport = function Delegate$clearExport(name) {
    if (Delegate[name]) {
        Delegate[name] = Delegate.Null;
    }
}

///////////////////////////////////////////////////////////////////////////////
// CultureInfo

var CultureInfo = function(name, numberFormat, dateFormat) {
    this.name = name;
    this.numberFormat = numberFormat;
    this.dateFormat = dateFormat;
}
CultureInfo.createClass('CultureInfo');

CultureInfo.Neutral = new CultureInfo('en-US',
    {
        naNSymbol: 'NaN',
        negativeSign: '-',
        positiveSign: '+',
        negativeInfinityText: '-Infinity',
        positiveInfinityText: 'Infinity',
        
        percentSymbol: '%',
        percentGroupSizes: [3],
        percentDecimalDigits: 2,
        percentDecimalSeparator: '.',
        percentGroupSeparator: ',',
        percentPositivePattern: '{0} %',
        percentNegativePattern: '-{0} %',

        currencySymbol:'$',
        currencyGroupSizes: [3],
        currencyDecimalDigits: 2,
        currencyDecimalSeparator: '.',
        currencyGroupSeparator: ',',
        currencyNegativePattern: '(${0})',
        currencyPositivePattern: '${0}',

        numberGroupSizes: [3],
        numberDecimalDigits: 2,
        numberDecimalSeparator: '.',
        numberGroupSeparator: ','
    },
    {
        amDesignator: 'AM',
        pmDesignator: 'PM',

        dateSeparator: '/',
        timeSeparator: ':',

        gmtDateTimePattern: 'ddd, dd MMM yyyy HH:mm:ss \'GMT\'',
        universalDateTimePattern: 'yyyy-MM-dd HH:mm:ssZ',
        sortableDateTimePattern: 'yyyy-MM-ddTHH:mm:ss',
        dateTimePattern: 'dddd, MMMM dd, yyyy h:mm:ss tt',

        longDatePattern: 'dddd, MMMM dd, yyyy',
        shortDatePattern: 'M/d/yyyy',

        longTimePattern: 'h:mm:ss tt',
        shortTimePattern: 'h:mm tt',

        firstDayOfWeek: 0,
        dayNames: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
        shortDayNames: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
        minimizedDayNames: ['Su','Mo','Tu','We','Th','Fr','Sa'],

        monthNames: ['January','February','March','April','May','June','July','August','September','October','November','December',''],
        shortMonthNames: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec','']
    });
CultureInfo.Current = CultureInfo.Neutral;

///////////////////////////////////////////////////////////////////////////////
// IArray

var IArray = function() { };
IArray.prototype = {
    getLength: null,
    getItem: null
}
IArray.createInterface('IArray');

///////////////////////////////////////////////////////////////////////////////
// IEnumerator

var IEnumerator = function() { };
IEnumerator.prototype = {
    get_current: null,
    moveNext: null,
    reset: null
}
IEnumerator.createInterface('IEnumerator');

///////////////////////////////////////////////////////////////////////////////
// IEnumerable

var IEnumerable = function() { };
IEnumerable.prototype = {
    getEnumerator: null
}
IEnumerable.createInterface('IEnumerable');

///////////////////////////////////////////////////////////////////////////////
// ArrayEnumerator

var ArrayEnumerator = function ArrayEnumerator$(array) {
    this._array = array;
    this._index = -1;
}
ArrayEnumerator.prototype = {
    get_current: function ArrayEnumerator$get_current() {
        return this._array[this._index];
    },
    moveNext: function ArrayEnumerator$moveNext() {
        this._index++;
        return (this._index < this._array.length);
    },
    reset: function ArrayEnumerator$reset() {
        this._index = -1;
    }
}

ArrayEnumerator.createClass('ArrayEnumerator', null, IEnumerator);

///////////////////////////////////////////////////////////////////////////////
// Array Extensions

Array.__interfaces = [ IArray, IEnumerable ];

Array.prototype.getLength = function Array$getLength() {
    return this.length;
}
Array.prototype.getItem = function Array$getItem(index) {
    return this[index];
}

Array.prototype.getEnumerator = function Array$getEnumerator() {
    return new ArrayEnumerator(this);
}

///////////////////////////////////////////////////////////////////////////////
// IDisposable

var IDisposable = function() { };
IDisposable.prototype = {
    dispose: null
}
IDisposable.createInterface('IDisposable');

///////////////////////////////////////////////////////////////////////////////
// IServiceProvider

var IServiceProvider = function() { };
IServiceProvider.prototype = {
    getService: null
}
IServiceProvider.createInterface('IServiceProvider');

///////////////////////////////////////////////////////////////////////////////
// IServiceContainer

var IServiceContainer = function() { };
IServiceContainer.prototype = {
    registerService: null,
    unregisterService: null
}
IServiceContainer.createInterface('IServiceContainer');

///////////////////////////////////////////////////////////////////////////////
// StringBuilder

var StringBuilder = function StringBuilder$(s) {

    if ((s !== undefined) && (s !== null)) {
        this._parts = [ s ];
    }
    else {
        this._parts = [];
    }
}
StringBuilder.prototype = {
    get_isEmpty: function StringBuilder$get_isEmpty() {
        return (this._parts.length == 0);
    },

    append: function StringBuilder$append(s) {
        if ((s !== undefined) && (s !== null)) {
            this._parts.add(s);
        }
    },

    appendLine: function StringBuilder$appendLine(s) {
        this.append(s);
        this.append('\r\n');
    },

    clear: function StringBuilder$clear() {
        this._parts.clear();
    },

    toString: function StringBuilder$toString() {
        return this._parts.join('');
    }
};

StringBuilder.createClass('StringBuilder');

///////////////////////////////////////////////////////////////////////////////
// EventArgs

var EventArgs = function EventArgs$() {
}
EventArgs.createClass('EventArgs');

EventArgs.Empty = new EventArgs();

///////////////////////////////////////////////////////////////////////////////
// XMLHttpRequest

if (!window.XMLHttpRequest) {
    window.XMLHttpRequest = function() {
        var progIDs = [ 'Msxml2.XMLHTTP', 'Microsoft.XMLHTTP' ];

        for (var i = 0; i < progIDs.length; i++) {
            try {
                var xmlHttp = new ActiveXObject(progIDs[i]);
                return xmlHttp;
            }
            catch (ex) {
            }
        }

        return null;
    }
}

///////////////////////////////////////////////////////////////////////////////
// XMLDocumentParser

var XMLDocumentParser = function() {
}
XMLDocumentParser.createClass('XMLDocumentParser');

XMLDocumentParser.parse = function XMLDocumentParser$parse(markup) {
    if (!window.DOMParser) {
        var progIDs = [ 'Msxml2.DOMDocument.3.0', 'Msxml2.DOMDocument' ];
        
        for (var i = 0; i < progIDs.length; i++) {
            try {
                var xmlDOM = new ActiveXObject(progIDs[i]);
                xmlDOM.async = false;
                xmlDOM.loadXML(markup);
                xmlDOM.setProperty('SelectionLanguage', 'XPath');
                
                return xmlDOM;
            }
            catch (ex) {
            }
        }
    }
    else {
        try {
            var domParser = new DOMParser();
            return domParser.parseFromString(markup, 'text/xml');
        }
        catch (ex) {
        }
    }

    return null;
}

////////////////////////////////////////////////////////////////////////////////
// ScriptLoader

var ScriptLoader = function ScriptLoader(scriptURLs) {
    Debug.assert((scriptURLs) && (scriptURLs.length));
    this._scriptURLs = scriptURLs;
    this._scriptLoadIndex = -1;
}
ScriptLoader.prototype = {
    _scriptURLs: null,
    _loadedHandler: null,
    _errorHandler: null,
    _isIE: false,
    _onLoadHandler: null,
    _onErrorHandler: null,
    _scriptLoadIndex: 0,
    _scriptElements: null,
    _loadedScripts: 0,
    _inError: false,
    _loaded: false,
    
    dispose: function ScriptLoader$dispose() {
        if (this._scriptElements) {
            for (var i = 0; i < this._scriptElements.length; i++) {
                var scriptElement = this._scriptElements[i];
                if (this._isIE) {
                    scriptElement.detachEvent('onreadystatechange', this._onLoadHandler);
                }
                else {
                    scriptElement.detachEvent('onload', this._onLoadHandler);
                    scriptElement.detachEvent('onerror', this._onErrorHandler);
                }
            }
            this._scriptElements = null;
        }
    },
    
    load: function ScriptLoader$load(loadInParallel, timeout, loadedHandler, errorHandler) {
        Debug.assert(loadedHandler);
        Debug.assert(errorHandler);
        this._loadedHandler = loadedHandler;
        this._errorHandler = errorHandler;
        this._isIE = (window.navigator.userAgent.indexOf('MSIE') >= 0);
        this._onLoadHandler = Delegate.create(this, this._onScriptLoad);
        if (!this._isIE) {
            this._onErrorHandler = Delegate.create(this, this._onScriptError);
        }
        this._scriptElements = [];
        if (loadInParallel) {
            for (var i = 0; i < this._scriptURLs.length; i++) {
                this._loadScript(this._scriptURLs[i]);
            }
        }
        else {
            this._scriptLoadIndex++;
            this._loadScript(this._scriptURLs[this._scriptLoadIndex]);
        }
        if (timeout) {
            window.setTimeout(Delegate.create(this, this._onScriptError), timeout);
        }
    },
    
    _loadScript: function ScriptLoader$_loadScript(scriptURL) {
        var scriptElement = document.createElement('SCRIPT');
        if (this._isIE) {
            scriptElement.attachEvent('onreadystatechange', this._onLoadHandler);
        }
        else {
            scriptElement.readyState = 'complete';
            scriptElement.attachEvent('onload', this._onLoadHandler);
            scriptElement.attachEvent('onerror', this._onErrorHandler);
        }
        scriptElement.type = 'text/javascript';
        scriptElement.src = scriptURL;
        this._scriptElements.add(scriptElement);
        document.getElementsByTagName('HEAD')[0].appendChild(scriptElement);
    },
    
    _onScriptError: function ScriptLoader$_onScriptError() {
        if ((!this._inError) && (!this._loaded)) {
            this._inError = true;
            this._errorHandler.invoke(this, EventArgs.Empty);
        }
    },
    
    _onScriptLoad: function ScriptLoader$_onScriptLoad() {
        if (this._inError) {
            return;
        }
        var scriptElement = window.event.srcElement;
        if (!scriptElement.readyState) {
            scriptElement = window.event.currentTarget;
        }

        if ((scriptElement.readyState != 'complete') && (scriptElement.readyState != 'loaded')) {
            return;
        }
        if (this._scriptLoadIndex != -1) {
            this._scriptLoadIndex++;
            if (this._scriptLoadIndex != this._scriptURLs.length) {
                this._loadScript(this._scriptURLs[this._scriptLoadIndex]);
                return;
            }
        }
        else {
            this._loadedScripts++;
            if (this._loadedScripts != this._scriptURLs.length) {
                return;
            }
        }
        this._loaded = true;
        this._loadedHandler.invoke(this, EventArgs.Empty);
    }
};

ScriptLoader.createClass('ScriptLoader', null, IDisposable);

////////////////////////////////////////////////////////////////////////////////
// ScriptHost

var ScriptHost = function ScriptHost() {
}
ScriptHost.get_isLoading = function ScriptHost$get_isLoading() {
    return ScriptHost._loading;
}
ScriptHost.add_load = function ScriptHost$add_load(value) {
    if (ScriptHost._loaded) {
        value.invoke(null, EventArgs.Empty);
    }
    else {
        ScriptHost._loadHandler = Delegate.combine(ScriptHost._loadHandler, value);
    }
}
ScriptHost.remove_load = function ScriptHost$remove_load(value) {
    ScriptHost._loadHandler = Delegate.remove(ScriptHost._loadHandler, value);
}
ScriptHost.add_unload = function ScriptHost$add_unload(value) {
    ScriptHost._unloadHandler = Delegate.combine(ScriptHost._unloadHandler, value);
}
ScriptHost.remove_unload = function ScriptHost$remove_unload(value) {
    ScriptHost._unloadHandler = Delegate.remove(ScriptHost._unloadHandler, value);
}
ScriptHost.close = function ScriptHost$close() {
    if (ScriptHost._fxScripts) {
        ScriptHost._fxScripts.dispose();
        ScriptHost._fxScripts = null;
    }
    if (ScriptHost._coreScripts) {
        ScriptHost._coreScripts.dispose();
        ScriptHost._coreScripts = null;
    }
    if (ScriptHost._unloadHandler) {
        ScriptHost._unloadHandler.invoke(null, EventArgs.Empty);
        ScriptHost._unloadHandler = null;
    }
    if (ScriptHost._windowLoadHandler) {
        window.detachEvent('onload', ScriptHost._windowLoadHandler);
        ScriptHost._windowLoadHandler = null;
    }
    if (ScriptHost._windowUnloadHandler) {
        window.detachEvent('onunload', ScriptHost._windowUnloadHandler);
        ScriptHost._windowUnloadHandler = null;
    }
}
ScriptHost.initialize = function ScriptHost$initialize(coreScriptURLs, fxScriptURLs) {
    if (!ScriptHost._initialized) {
        ScriptHost._initialized = true;
        if (ScriptHost._windowLoadHandler) {
            window.detachEvent('onload', ScriptHost._windowLoadHandler);
            ScriptHost._windowLoadHandler = null;
        }
        if ((coreScriptURLs) && (coreScriptURLs.length)) {
            ScriptHost._coreScripts = new ScriptLoader(coreScriptURLs);
        }
        if ((fxScriptURLs) && (fxScriptURLs.length)) {
            ScriptHost._fxScripts = new ScriptLoader(fxScriptURLs);
        }
        if ((!ScriptHost._coreScripts) && (!ScriptHost._fxScripts)) {
            ScriptHost._onLoaded();
        }
        else {
            ScriptHost._loadScripts();
        }
    }
}
ScriptHost._loadScripts = function ScriptHost$_loadScripts() {
    ScriptHost._loading = true;
    if (ScriptHost._coreScripts) {
        ScriptHost._coreScripts.load(false, 20 * 1000, Delegate.create(null, ScriptHost._onScriptsCompleted), Delegate.create(null, ScriptHost._onScriptsError));
        return;
    }
    else {
        ScriptHost._fxScripts.load(true, 20 * 1000, Delegate.create(null, ScriptHost._onScriptsCompleted), Delegate.create(null, ScriptHost._onScriptsError));
    }
}
ScriptHost._onLoaded = function ScriptHost$_onLoaded() {
    ScriptHost._loaded = true;
    if (window.main) {
        window.main();
    }
    if (ScriptHost._loadHandler) {
        ScriptHost._loadHandler.invoke(null, EventArgs.Empty);
        ScriptHost._loadHandler = null;
    }
}
ScriptHost._onScriptsCompleted = function ScriptHost$_onScriptsCompleted(sender, e) {
    if (sender == ScriptHost._coreScripts) {
        ScriptHost._coreScripts.dispose();
        ScriptHost._coreScripts = null;
        if (ScriptHost._fxScripts) {
            ScriptHost._fxScripts.load(true, 20 * 1000, Delegate.create(null, ScriptHost._onScriptsCompleted), Delegate.create(null, ScriptHost._onScriptsError));
            return;
        }
    }
    else {
        ScriptHost._fxScripts.dispose();
        ScriptHost._fxScripts = null;
    }
    ScriptHost._loading = false;
    ScriptHost._onLoaded();
}
ScriptHost._onScriptsError = function ScriptHost$_onScriptsError(sender, e) {
}
ScriptHost._onWindowLoad = function ScriptHost$_onWindowLoad() {
    ScriptHost.initialize(null, null);
}
ScriptHost._onWindowUnload = function ScriptHost$_onWindowUnload() {
    ScriptHost.close();
}

ScriptHost.createClass('ScriptHost');

ScriptHost._coreScripts = null;
ScriptHost._fxScripts = null;
ScriptHost._loadHandler = null;
ScriptHost._unloadHandler = null;
ScriptHost._initialized = false;
ScriptHost._loading = false;
ScriptHost._loaded = false;
ScriptHost._windowLoadHandler = Delegate.create(null, ScriptHost._onWindowLoad);
ScriptHost._windowUnloadHandler = Delegate.create(null, ScriptHost._onWindowUnload);
window.attachEvent('onload', ScriptHost._windowLoadHandler);
window.attachEvent('onunload', ScriptHost._windowUnloadHandler);
// Script# Framework
// Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.CollectionChangedAction

ScriptFX.CollectionChangedAction = function() { };
ScriptFX.CollectionChangedAction.prototype = {
    add: 0, 
    remove: 1, 
    reset: 2
}
ScriptFX.CollectionChangedAction.createEnum('ScriptFX.CollectionChangedAction', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX._registeredEvent

ScriptFX.$create__registeredEvent = function ScriptFX__registeredEvent(eventType, sender, eventArgs, eventCookie) {
    var $o = { };
    $o.eventType = eventType;
    $o.sender = sender;
    $o.eventArgs = eventArgs;
    $o.eventCookie = eventCookie;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.IEventManager

ScriptFX.IEventManager = function() { };
ScriptFX.IEventManager.prototype = {
    raiseEvent : null,
    registerEvent : null,
    registerEventHandler : null,
    unregisterEvent : null,
    unregisterEventHandler : null
}
ScriptFX.IEventManager.createInterface('ScriptFX.IEventManager');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ISupportInitialize

ScriptFX.ISupportInitialize = function() { };
ScriptFX.ISupportInitialize.prototype = {
    beginInitialize : null,
    endInitialize : null
}
ScriptFX.ISupportInitialize.createInterface('ScriptFX.ISupportInitialize');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.INotifyDisposing

ScriptFX.INotifyDisposing = function() { };
ScriptFX.INotifyDisposing.prototype = {
    add_disposing : null,
    remove_disposing : null
}
ScriptFX.INotifyDisposing.createInterface('ScriptFX.INotifyDisposing');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HostName

ScriptFX.HostName = function() { };
ScriptFX.HostName.prototype = {
    other: 0, 
    IE: 1, 
    mozilla: 2, 
    safari: 3, 
    opera: 4
}
ScriptFX.HostName.createEnum('ScriptFX.HostName', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.INotifyCollectionChanged

ScriptFX.INotifyCollectionChanged = function() { };
ScriptFX.INotifyCollectionChanged.prototype = {
    add_collectionChanged : null,
    remove_collectionChanged : null
}
ScriptFX.INotifyCollectionChanged.createInterface('ScriptFX.INotifyCollectionChanged');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.INotifyPropertyChanged

ScriptFX.INotifyPropertyChanged = function() { };
ScriptFX.INotifyPropertyChanged.prototype = {
    add_propertyChanged : null,
    remove_propertyChanged : null
}
ScriptFX.INotifyPropertyChanged.createInterface('ScriptFX.INotifyPropertyChanged');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ITask

ScriptFX.ITask = function() { };
ScriptFX.ITask.prototype = {
    execute : null
}
ScriptFX.ITask.createInterface('ScriptFX.ITask');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.IObjectWithOwner

ScriptFX.IObjectWithOwner = function() { };
ScriptFX.IObjectWithOwner.prototype = {
    get_owner : null,
    setOwner : null
}
ScriptFX.IObjectWithOwner.createInterface('ScriptFX.IObjectWithOwner');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Application

ScriptFX.Application = function ScriptFX_Application() {
    this._disposableObjects = [];
    this._idleFrequency = 100;
    ScriptHost.add_load(Delegate.create(this, this._onScriptHostLoad));
    ScriptHost.add_unload(Delegate.create(this, this._onScriptHostUnload));
    this._windowUnloadingHandler = Delegate.create(this, this._onWindowUnloading);
    window.attachEvent('onbeforeunload', this._windowUnloadingHandler);
    this._windowErrorHandler = Delegate.create(this, this._onWindowError);
    window.attachEvent('onerror', this._windowErrorHandler);
    var rootElement = document.documentElement;
    var className = rootElement.className;
    if (className.startsWith('$')) {
        var hostInfo = this.get_host();
        className = className.replace('$browser', Enum.toString(ScriptFX.HostName, hostInfo.get_name()));
        className = className.replace('$majorver', hostInfo.get_majorVersion().toString());
        className = className.replace('$minorver', hostInfo.get_minorVersion().toString());
        rootElement.className = className;
    }
}
ScriptFX.Application.prototype = {
    _host: null,
    _isIE: 0,
    _scriptlets: null,
    _loaded: false,
    _disposing: false,
    _firstLoad: false,
    _sessionState: null,
    _history: null,
    _events: null,
    _disposableObjects: null,
    _idleFrequency: 0,
    _idleTimer: 0,
    _taskQueue: null,
    _taskTimer: 0,
    _registeredEventHandlers: null,
    _registeredEventTypes: null,
    _registeredEvents: null,
    _services: null,
    _windowUnloadingHandler: null,
    _windowErrorHandler: null,
    _idleTimerTickHandler: null,
    _taskTimerTickHandler: null,
    
    get_domain: function ScriptFX_Application$get_domain() {
        return window.document.domain;
    },
    set_domain: function ScriptFX_Application$set_domain(value) {
        window.document.domain = value;
        return value;
    },
    
    get__events: function ScriptFX_Application$get__events() {
        if (!this._events) {
            this._events = new ScriptFX.EventList();
        }
        return this._events;
    },
    
    get_history: function ScriptFX_Application$get_history() {
        Debug.assert(this._history, 'History has not been enabled.');
        return this._history;
    },
    
    get_host: function ScriptFX_Application$get_host() {
        if (!this._host) {
            this._host = new ScriptFX.HostInfo();
        }
        return this._host;
    },
    
    get_idleFrequency: function ScriptFX_Application$get_idleFrequency() {
        return this._idleFrequency;
    },
    set_idleFrequency: function ScriptFX_Application$set_idleFrequency(value) {
        Debug.assert(value >= 100, 'IdleFrequency must be atleast 100ms');
        this._idleFrequency = value;
        return value;
    },
    
    get_isFirstLoad: function ScriptFX_Application$get_isFirstLoad() {
        return this._firstLoad;
    },
    
    get_isIE: function ScriptFX_Application$get_isIE() {
        if (!this._isIE) {
            this._isIE = (this.get_host().get_name() === ScriptFX.HostName.IE) ? 1 : -1;
        }
        return (this._isIE === 1) ? true : false;
    },
    
    get_sessionState: function ScriptFX_Application$get_sessionState() {
        Debug.assert(this._loaded, 'You must wait until the load event before accessing session.');
        Debug.assert(this._sessionState, 'In order to use session, you must add an <input type=\"hidden\" id=\"__session\" /> within a <form>.');
        return this._sessionState;
    },
    
    add_error: function ScriptFX_Application$add_error(value) {
        this.get__events().addHandler('error', value);
    },
    remove_error: function ScriptFX_Application$remove_error(value) {
        this.get__events().removeHandler('error', value);
    },
    
    add_idle: function ScriptFX_Application$add_idle(value) {
        this.get__events().addHandler('idle', value);
        if (!this._idleTimer) {
            if (!this._idleTimerTickHandler) {
                this._idleTimerTickHandler = Delegate.create(this, this._onIdleTimerTick);
            }
            this._idleTimer = window.setTimeout(this._idleTimerTickHandler, this._idleFrequency);
        }
    },
    remove_idle: function ScriptFX_Application$remove_idle(value) {
        var isActive = this.get__events().removeHandler('idle', value);
        if ((!isActive) && (this._idleTimer)) {
            window.clearTimeout(this._idleTimer);
            this._idleTimer = 0;
        }
    },
    
    add_load: function ScriptFX_Application$add_load(value) {
        if (this._loaded) {
            value.invoke(this, EventArgs.Empty);
        }
        else {
            this.get__events().addHandler('load', value);
        }
    },
    remove_load: function ScriptFX_Application$remove_load(value) {
        this.get__events().removeHandler('load', value);
    },
    
    add_unload: function ScriptFX_Application$add_unload(value) {
        this.get__events().addHandler('unload', value);
    },
    remove_unload: function ScriptFX_Application$remove_unload(value) {
        this.get__events().removeHandler('unload', value);
    },
    
    add_unloading: function ScriptFX_Application$add_unloading(value) {
        this.get__events().addHandler('unloading', value);
    },
    remove_unloading: function ScriptFX_Application$remove_unloading(value) {
        this.get__events().removeHandler('unloading', value);
    },
    
    addTask: function ScriptFX_Application$addTask(task) {
        if (!this._taskQueue) {
            this._taskQueue = [];
        }
        this._taskQueue.enqueue(task);
        if (!this._taskTimer) {
            if (!this._taskTimerTickHandler) {
                this._taskTimerTickHandler = Delegate.create(this, this._onTaskTimerTick);
            }
            this._taskTimer = window.setTimeout(this._taskTimerTickHandler, 0);
        }
    },
    
    enableHistory: function ScriptFX_Application$enableHistory() {
        if (this._history) {
            return;
        }
        this._history = ScriptFX.HistoryManager._createHistory();
    },
    
    getService: function ScriptFX_Application$getService(serviceType) {
        Debug.assert(serviceType);
        if ((serviceType === IServiceContainer) || (serviceType === ScriptFX.IEventManager)) {
            return this;
        }
        if (this._services) {
            var name = serviceType.get_fullName().replace('.', '$');
            return this._services[name];
        }
        return null;
    },
    
    _onIdleTimerTick: function ScriptFX_Application$_onIdleTimerTick() {
        this._idleTimer = 0;
        var handler = this.get__events().getHandler('idle');
        if (handler) {
            handler.invoke(this, EventArgs.Empty);
            this._idleTimer = window.setTimeout(this._idleTimerTickHandler, this._idleFrequency);
        }
    },
    
    _onScriptHostLoad: function ScriptFX_Application$_onScriptHostLoad(sender, e) {
        var sessionElement = $('__session');
        if (sessionElement) {
            var value = sessionElement.value;
            if (String.isNullOrEmpty(value)) {
                this._firstLoad = true;
                this._sessionState = {};
            }
            else {
                this._sessionState = ScriptFX.JSON.deserialize(value);
                if (isUndefined(this._sessionState['__appLoaded'])) {
                    this._firstLoad = true;
                }
            }
            this._sessionState['__appLoaded'] = true;
        }
        else {
            this._firstLoad = true;
        }
        if (this._scriptlets) {
            for (var i = 0; i < this._scriptlets.length; i += 2) {
                this._scriptlets[i].main(this._scriptlets[i + 1]);
            }
            this._scriptlets = null;
        }
        this._loaded = true;
        var handler = this.get__events().getHandler('load');
        if (handler) {
            handler.invoke(this, EventArgs.Empty);
        }
        if (this._history) {
            this._history._initialize();
        }
    },
    
    _onScriptHostUnload: function ScriptFX_Application$_onScriptHostUnload(sender, e) {
        if (!this._disposing) {
            this._disposing = true;
            if (this._taskTimer) {
                window.clearTimeout(this._taskTimer);
            }
            if (this._idleTimer) {
                window.clearTimeout(this._idleTimer);
            }
            var handler = this.get__events().getHandler('unload');
            if (handler) {
                handler.invoke(this, EventArgs.Empty);
            }
            if (this._taskQueue) {
                while (this._taskQueue.length) {
                    var task = this._taskQueue.dequeue();
                    if (Type.canCast(task, IDisposable)) {
                        (task).dispose();
                    }
                }
            }
            if (this._disposableObjects.length) {
                var $enum1 = this._disposableObjects.getEnumerator();
                while ($enum1.moveNext()) {
                    var disposable = $enum1.get_current();
                    disposable.dispose();
                }
                this._disposableObjects.clear();
            }
            if (this._history) {
                this._history.dispose();
                this._history = null;
            }
            window.detachEvent('onbeforeunload', this._windowUnloadingHandler);
            window.detachEvent('onerror', this._windowErrorHandler);
            this._windowUnloadingHandler = null;
            this._windowErrorHandler = null;
            this._taskTimerTickHandler = null;
            this._idleTimerTickHandler = null;
        }
    },
    
    _onTaskTimerTick: function ScriptFX_Application$_onTaskTimerTick() {
        this._taskTimer = 0;
        if (this._taskQueue.length) {
            var task = this._taskQueue.dequeue();
            if (!task.execute()) {
                this._taskQueue.enqueue(task);
            }
            else {
                if (Type.canCast(task, IDisposable)) {
                    (task).dispose();
                }
            }
            if (this._taskQueue.length) {
                this._taskTimer = window.setTimeout(this._taskTimerTickHandler, 0);
            }
        }
    },
    
    _onWindowError: function ScriptFX_Application$_onWindowError() {
        var handler = this.get__events().getHandler('error');
        if (handler) {
            var ce = new ScriptFX.CancelEventArgs();
            ce.set_canceled(true);
            handler.invoke(this, ce);
            if (ce.get_canceled()) {
                window.event.returnValue = false;
            }
        }
    },
    
    _onWindowUnloading: function ScriptFX_Application$_onWindowUnloading() {
        window.event.avoidReturn = true;
        var handler = this.get__events().getHandler('unloading');
        if (handler) {
            var e = new ScriptFX.ApplicationUnloadingEventArgs();
            handler.invoke(this, e);
        }
        if (this._sessionState) {
            var sessionElement = $('__session');
            sessionElement.value = ScriptFX.JSON.serialize(this._sessionState);
        }
    },
    
    raiseEvent: function ScriptFX_Application$raiseEvent(eventType, sender, e) {
        Debug.assert(String.isNullOrEmpty(eventType));
        Debug.assert(sender);
        Debug.assert(e);
        if (this._registeredEventHandlers) {
            var handler = this._registeredEventHandlers[eventType];
            if (handler) {
                handler.invoke(sender, e);
            }
        }
    },
    
    registerDisposableObject: function ScriptFX_Application$registerDisposableObject(disposableObject) {
        if (!this._disposing) {
            this._disposableObjects.add(disposableObject);
        }
    },
    
    registerEvent: function ScriptFX_Application$registerEvent(eventType, sender, e) {
        Debug.assert(String.isNullOrEmpty(eventType));
        Debug.assert(sender);
        Debug.assert(e);
        if (this._registeredEventHandlers) {
            var handler = this._registeredEventHandlers[eventType];
            if (handler) {
                handler.invoke(sender, e);
            }
        }
        if (!this._registeredEvents) {
            this._registeredEvents = [];
        }
        if (!this._registeredEventTypes) {
            this._registeredEventTypes = {};
            this._registeredEventTypes[eventType] = 1;
        }
        else {
            var eventCount = this._registeredEventTypes[eventType];
            if (isUndefined(eventCount)) {
                this._registeredEventTypes[eventType] = 1;
            }
            else {
                this._registeredEventTypes[eventType] = 1 + eventCount;
            }
        }
        var eventInfo = ScriptFX.$create__registeredEvent(eventType, sender, e, this._registeredEvents.length);
        this._registeredEvents.add(eventInfo);
        return eventInfo.eventCookie;
    },
    
    registerEventHandler: function ScriptFX_Application$registerEventHandler(eventType, handler) {
        Debug.assert(!String.isNullOrEmpty(eventType));
        Debug.assert(handler);
        var existingHandler = null;
        if (!this._registeredEventHandlers) {
            this._registeredEventHandlers = {};
        }
        else {
            existingHandler = this._registeredEventHandlers[eventType];
        }
        this._registeredEventHandlers[eventType] = Delegate.combine(existingHandler, handler);
        if (!isNullOrUndefined(this._registeredEventTypes[eventType])) {
            var $enum1 = this._registeredEvents.getEnumerator();
            while ($enum1.moveNext()) {
                var eventInfo = $enum1.get_current();
                if (!eventInfo) {
                    continue;
                }
                if (eventInfo.eventType === eventType) {
                    handler.invoke(eventInfo.sender, eventInfo.eventArgs);
                }
            }
        }
    },
    
    registerService: function ScriptFX_Application$registerService(serviceType, service) {
        Debug.assert(serviceType);
        Debug.assert(service);
        if (!this._services) {
            this._services = {};
        }
        var name = serviceType.get_fullName().replace('.', '$');
        Debug.assert(!this._services[name]);
        this._services[name] = service;
    },
    
    run: function ScriptFX_Application$run(scriptletType, args) {
        if (this._loaded) {
            scriptletType.main(args);
        }
        else {
            if (!this._scriptlets) {
                this._scriptlets = [];
            }
            this._scriptlets.add(scriptletType);
            this._scriptlets.add(args);
        }
    },
    
    unregisterDisposableObject: function ScriptFX_Application$unregisterDisposableObject(disposableObject) {
        Debug.assert(disposableObject);
        if (!this._disposing) {
            this._disposableObjects.remove(disposableObject);
        }
    },
    
    unregisterEvent: function ScriptFX_Application$unregisterEvent(eventCookie) {
        Debug.assert(eventCookie);
        Debug.assert(Type.canCast(eventCookie, Number));
        Debug.assert(this._registeredEvents);
        Debug.assert(this._registeredEventTypes);
        var eventInfo = this._registeredEvents[eventCookie];
        Debug.assert(eventInfo);
        var eventCount = this._registeredEventTypes[eventInfo.eventType];
        Debug.assert(eventCount >= 1);
        if (eventCount === 1) {
            delete this._registeredEventTypes[eventInfo.eventType];
        }
        else {
            this._registeredEventTypes[eventInfo.eventType] = eventCount - 1;
        }
        this._registeredEvents[eventCookie] = null;
    },
    
    unregisterEventHandler: function ScriptFX_Application$unregisterEventHandler(eventType, handler) {
        Debug.assert(!String.isNullOrEmpty(eventType));
        Debug.assert(handler);
        if (this._registeredEventHandlers) {
            var existingHandler = this._registeredEventHandlers[eventType];
            if (existingHandler) {
                existingHandler = Delegate.remove(existingHandler, handler);
                if (!existingHandler) {
                    delete this._registeredEventHandlers[eventType];
                }
                else {
                    this._registeredEventHandlers[eventType] = existingHandler;
                }
            }
        }
    },
    
    unregisterService: function ScriptFX_Application$unregisterService(serviceType) {
        Debug.assert(serviceType);
        if (this._services) {
            var name = serviceType.get_fullName().replace('.', '$');
            delete this._services[name];
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.CancelEventArgs

ScriptFX.CancelEventArgs = function ScriptFX_CancelEventArgs() {
    ScriptFX.CancelEventArgs.constructBase(this);
}
ScriptFX.CancelEventArgs.prototype = {
    _canceled$1: false,
    
    get_canceled: function ScriptFX_CancelEventArgs$get_canceled() {
        return this._canceled$1;
    },
    set_canceled: function ScriptFX_CancelEventArgs$set_canceled(value) {
        this._canceled$1 = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.CollectionChangedEventArgs

ScriptFX.CollectionChangedEventArgs = function ScriptFX_CollectionChangedEventArgs(action, item) {
    ScriptFX.CollectionChangedEventArgs.constructBase(this);
    this._action$1 = action;
    this._item$1 = item;
}
ScriptFX.CollectionChangedEventArgs.prototype = {
    _action$1: 0,
    _item$1: null,
    
    get_action: function ScriptFX_CollectionChangedEventArgs$get_action() {
        return this._action$1;
    },
    
    get_item: function ScriptFX_CollectionChangedEventArgs$get_item() {
        return this._item$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ApplicationUnloadingEventArgs

ScriptFX.ApplicationUnloadingEventArgs = function ScriptFX_ApplicationUnloadingEventArgs() {
    ScriptFX.ApplicationUnloadingEventArgs.constructBase(this);
}
ScriptFX.ApplicationUnloadingEventArgs.prototype = {
    
    setUnloadPrompt: function ScriptFX_ApplicationUnloadingEventArgs$setUnloadPrompt(prompt) {
        window.event.returnValue = prompt;
        window.event.avoidReturn = false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HistoryManager

ScriptFX.HistoryManager = function ScriptFX_HistoryManager(enabled, iframe) {
    this._enabled = enabled;
    this._iframe = iframe;
}
ScriptFX.HistoryManager._createHistory = function ScriptFX_HistoryManager$_createHistory() {
    var hostName = ScriptFX.Application.current.get_host().get_name();
    if ((hostName !== ScriptFX.HostName.IE) && (hostName !== ScriptFX.HostName.mozilla)) {
        return new ScriptFX.HistoryManager(false, null);
    }
    var iframe = null;
    if (hostName === ScriptFX.HostName.IE) {
        iframe = $('_historyFrame');
        Debug.assert(iframe, 'You must have an <iframe id=\"_historyFrame\" src=\"Empty.htm\" /> tag on your page.');
    }
    return new ScriptFX.HistoryManager(true, iframe);
}
ScriptFX.HistoryManager.prototype = {
    _enabled: false,
    _iframe: null,
    _emptyPageURL: null,
    _iframeLoadHandler: null,
    _ignoreTimer: false,
    _ignoreIFrame: false,
    _currentEntry: null,
    
    get_isEnabled: function ScriptFX_HistoryManager$get_isEnabled() {
        return this._enabled;
    },
    
    add_navigated: function ScriptFX_HistoryManager$add_navigated(value) {
        this.__navigated = Delegate.combine(this.__navigated, value);
    },
    remove_navigated: function ScriptFX_HistoryManager$remove_navigated(value) {
        this.__navigated = Delegate.remove(this.__navigated, value);
    },
    
    __navigated: null,
    
    addEntry: function ScriptFX_HistoryManager$addEntry(entryName) {
        Debug.assert(!String.isNullOrEmpty(entryName));
        Debug.assert(!$(entryName), 'The entry identifier should not be the same as an element ID.');
        if (!this._enabled) {
            return;
        }
        this._ignoreTimer = true;
        if (this._iframe) {
            this._ignoreIFrame = true;
            this._iframe.src = this._emptyPageURL + entryName;
        }
        else {
            this._setCurrentEntry(entryName);
        }
    },
    
    dispose: function ScriptFX_HistoryManager$dispose() {
        if (this._iframe) {
            this._iframe.detachEvent('onload', this._iframeLoadHandler);
            this._iframe = null;
        }
    },
    
    _getCurrentEntry: function ScriptFX_HistoryManager$_getCurrentEntry() {
        var entryName = window.location.hash;
        if ((entryName.length) && (entryName.charAt(0) === '#')) {
            entryName = entryName.substr(1);
        }
        return entryName;
    },
    
    goBack: function ScriptFX_HistoryManager$goBack() {
        window.history.back();
    },
    
    goForward: function ScriptFX_HistoryManager$goForward() {
        window.history.forward();
    },
    
    _initialize: function ScriptFX_HistoryManager$_initialize() {
        if (!this._enabled) {
            return;
        }
        ScriptFX.Application.current.add_idle(Delegate.create(this, this._onAppIdle));
        if (this._iframe) {
            Debug.assert(this._iframe.src.length, 'You must set the Src attribute of the history iframe element to an empty page.');
            this._emptyPageURL = this._iframe.src + '?';
            this._iframeLoadHandler = Delegate.create(this, this._onIFrameLoad);
            this._iframe.attachEvent('onload', this._iframeLoadHandler);
        }
        this._currentEntry = this._getCurrentEntry();
        this._onNavigated(this._currentEntry);
    },
    
    _onAppIdle: function ScriptFX_HistoryManager$_onAppIdle(sender, e) {
        var entryName = this._getCurrentEntry();
        if (entryName !== this._currentEntry) {
            if (this._ignoreTimer) {
                return;
            }
            this._currentEntry = entryName;
            this._onNavigated(entryName);
        }
        else {
            this._ignoreTimer = false;
        }
    },
    
    _onIFrameLoad: function ScriptFX_HistoryManager$_onIFrameLoad() {
        var entryName = this._iframe.contentWindow.location.search;
        if ((entryName.length) && (entryName.charAt(0) === '?')) {
            entryName = entryName.substr(1);
        }
        this._setCurrentEntry(entryName);
        if (this._ignoreIFrame) {
            this._ignoreIFrame = false;
            return;
        }
        this._onNavigated(entryName);
    },
    
    _onNavigated: function ScriptFX_HistoryManager$_onNavigated(entryName) {
        if (this.__navigated) {
            this.__navigated.invoke(this, new ScriptFX.HistoryEventArgs(entryName));
        }
    },
    
    _setCurrentEntry: function ScriptFX_HistoryManager$_setCurrentEntry(entryName) {
        this._currentEntry = entryName;
        window.location.hash = entryName;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HistoryEventArgs

ScriptFX.HistoryEventArgs = function ScriptFX_HistoryEventArgs(entryName) {
    ScriptFX.HistoryEventArgs.constructBase(this);
    this._entryName$1 = entryName;
}
ScriptFX.HistoryEventArgs.prototype = {
    _entryName$1: null,
    
    get_entryName: function ScriptFX_HistoryEventArgs$get_entryName() {
        return this._entryName$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.HostInfo

ScriptFX.HostInfo = function ScriptFX_HostInfo() {
    var userAgent = window.navigator.userAgent.toLowerCase();
    var version = null;
    var index;
    if ((index = userAgent.indexOf('opera')) >= 0) {
        this._name = ScriptFX.HostName.opera;
        version = userAgent.substr(index + 6);
    }
    else if ((index = userAgent.indexOf('msie')) >= 0) {
        this._name = ScriptFX.HostName.IE;
        version = userAgent.substr(index + 5);
    }
    else if ((index = userAgent.indexOf('safari')) >= 0) {
        this._name = ScriptFX.HostName.safari;
        version = userAgent.substr(index + 7);
    }
    else if ((index = userAgent.indexOf('firefox')) >= 0) {
        this._name = ScriptFX.HostName.mozilla;
        version = userAgent.substr(index + 8);
    }
    else if (userAgent.indexOf('gecko') >= 0) {
        this._name = ScriptFX.HostName.mozilla;
        version = window.navigator.appVersion;
    }
    if (version) {
        this._version = parseFloat(version);
        this._majorVersion = parseInt(this._version);
        if ((index = version.indexOf('.')) >= 0) {
            this._minorVersion = parseInt(version.substr(index + 1));
        }
    }
}
ScriptFX.HostInfo.prototype = {
    _name: 0,
    _version: 0,
    _majorVersion: 0,
    _minorVersion: 0,
    
    get_majorVersion: function ScriptFX_HostInfo$get_majorVersion() {
        return this._majorVersion;
    },
    
    get_minorVersion: function ScriptFX_HostInfo$get_minorVersion() {
        return this._minorVersion;
    },
    
    get_name: function ScriptFX_HostInfo$get_name() {
        return this._name;
    },
    
    get_version: function ScriptFX_HostInfo$get_version() {
        return this._version;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.EventList

ScriptFX.EventList = function ScriptFX_EventList() {
}
ScriptFX.EventList.prototype = {
    _events: null,
    
    addHandler: function ScriptFX_EventList$addHandler(key, handler) {
        Debug.assert(!String.isNullOrEmpty(key));
        Debug.assert(handler);
        if (!this._events) {
            this._events = {};
        }
        this._events[key] = Delegate.combine(this._events[key], handler);
    },
    
    getHandler: function ScriptFX_EventList$getHandler(key) {
        Debug.assert(!String.isNullOrEmpty(key));
        if (this._events) {
            return this._events[key];
        }
        return null;
    },
    
    removeHandler: function ScriptFX_EventList$removeHandler(key, handler) {
        Debug.assert(!String.isNullOrEmpty(key));
        Debug.assert(handler);
        if (this._events) {
            var sourceHandler = this._events[key];
            if (sourceHandler) {
                var newHandler = Delegate.remove(sourceHandler, handler);
                this._events[key] = newHandler;
                return (newHandler);
            }
        }
        return false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.JSON

ScriptFX.JSON = function ScriptFX_JSON() {
}
ScriptFX.JSON.deserialize = function ScriptFX_JSON$deserialize(s) {
    if (String.isNullOrEmpty(s)) {
        return null;
    }
    if (!ScriptFX.JSON._dateRegex) {
        ScriptFX.JSON._dateRegex = new RegExp('(\'|\")\\\\@(-?[0-9]+)@(\'|\")', 'gm');
    }
    s = s.replace(ScriptFX.JSON._dateRegex, 'new Date($2)');
    return eval('(' + s + ')');
}
ScriptFX.JSON.serialize = function ScriptFX_JSON$serialize(o) {
    if (isNullOrUndefined(o)) {
        return String.Empty;
    }
    var sb = new StringBuilder();
    ScriptFX.JSON._serializeCore(sb, o);
    return sb.toString();
}
ScriptFX.JSON._serializeCore = function ScriptFX_JSON$_serializeCore(sb, o) {
    if (isNullOrUndefined(o)) {
        sb.append('null');
        return;
    }
    var scriptType = typeof(o);
    switch (scriptType) {
        case 'boolean':
            sb.append(o.toString());
            return;
        case 'number':
            sb.append((isFinite(o)) ? o.toString() : 'null');
            return;
        case 'string':
            sb.append((o).quote());
            return;
        case 'object':
            if (Array.isInstance(o)) {
                sb.append('[');
                var a = o;
                var length = a.length;
                var first = true;
                for (var i = 0; i < length; i++) {
                    if (first) {
                        first = false;
                    }
                    else {
                        sb.append(',');
                    }
                    ScriptFX.JSON._serializeCore(sb, a[i]);
                }
                sb.append(']');
            }
            else if (Date.isInstance(o)) {
                var d = o;
                var utcValue = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
                sb.append('\"\\@');
                sb.append(utcValue.toString());
                sb.append('@\"');
            }
            else if (RegExp.isInstance(o)) {
                sb.append(o.toString());
            }
            else {
                sb.append('{');
                var first = true;
                var $dict1 = o;
                for (var $key2 in $dict1) {
                    var entry = { key: $key2, value: $dict1[$key2] };
                    if ((entry.key).startsWith('$') || Function.isInstance(entry.value)) {
                        continue;
                    }
                    if (first) {
                        first = false;
                    }
                    else {
                        sb.append(',');
                    }
                    sb.append(entry.key);
                    sb.append(':');
                    ScriptFX.JSON._serializeCore(sb, entry.value);
                }
                sb.append('}');
            }
            return;
        default:
            Debug.fail(scriptType + ' is not supported for JSON serialization.');
            sb.append('null');
            return;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.PropertyChangedEventArgs

ScriptFX.PropertyChangedEventArgs = function ScriptFX_PropertyChangedEventArgs(propertyName) {
    ScriptFX.PropertyChangedEventArgs.constructBase(this);
    this._propertyName$1 = propertyName;
}
ScriptFX.PropertyChangedEventArgs.prototype = {
    _propertyName$1: null,
    
    get_propertyName: function ScriptFX_PropertyChangedEventArgs$get_propertyName() {
        return this._propertyName$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.ObservableCollection

ScriptFX.ObservableCollection = function ScriptFX_ObservableCollection(owner, disposableItems) {
    this._owner = owner;
    this._items = [];
    this._disposableItems = disposableItems;
}
ScriptFX.ObservableCollection.prototype = {
    _owner: null,
    _items: null,
    _disposableItems: false,
    _handler: null,
    
    add_collectionChanged: function ScriptFX_ObservableCollection$add_collectionChanged(value) {
        this._handler = Delegate.combine(this._handler, value);
    },
    remove_collectionChanged: function ScriptFX_ObservableCollection$remove_collectionChanged(value) {
        this._handler = Delegate.remove(this._handler, value);
    },
    
    add: function ScriptFX_ObservableCollection$add(item) {
        (item).setOwner(this._owner);
        this._items.add(item);
        if (this._handler) {
            this._handler.invoke(this, new ScriptFX.CollectionChangedEventArgs(ScriptFX.CollectionChangedAction.add, item));
        }
    },
    
    clear: function ScriptFX_ObservableCollection$clear() {
        if (this._items.length) {
            var $enum1 = this._items.getEnumerator();
            while ($enum1.moveNext()) {
                var item = $enum1.get_current();
                item.setOwner(null);
            }
            this._items.clear();
            if (this._handler) {
                this._handler.invoke(this, new ScriptFX.CollectionChangedEventArgs(ScriptFX.CollectionChangedAction.reset, null));
            }
        }
    },
    
    contains: function ScriptFX_ObservableCollection$contains(item) {
        return this._items.contains(item);
    },
    
    dispose: function ScriptFX_ObservableCollection$dispose() {
        if (this._disposableItems) {
            var $enum1 = this._items.getEnumerator();
            while ($enum1.moveNext()) {
                var item = $enum1.get_current();
                item.dispose();
            }
        }
        this._items = null;
        this._owner = null;
        this._handler = null;
    },
    
    getEnumerator: function ScriptFX_ObservableCollection$getEnumerator() {
        return this._items.getEnumerator();
    },
    
    getItem: function ScriptFX_ObservableCollection$getItem(index) {
        return this._items[index];
    },
    
    getItems: function ScriptFX_ObservableCollection$getItems() {
        return this._items;
    },
    
    getLength: function ScriptFX_ObservableCollection$getLength() {
        return this._items.length;
    },
    
    remove: function ScriptFX_ObservableCollection$remove(item) {
        if (this._items.contains(item)) {
            (item).setOwner(null);
            this._items.remove(item);
            if (this._handler) {
                this._handler.invoke(this, new ScriptFX.CollectionChangedEventArgs(ScriptFX.CollectionChangedAction.remove, item));
            }
        }
    }
}


Type.createNamespace('ScriptFX.Net');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPStatusCode

ScriptFX.Net.HTTPStatusCode = function() { };
ScriptFX.Net.HTTPStatusCode.prototype = {
    canContinue: 100, 
    switchingProtocols: 101, 
    OK: 200, 
    created: 201, 
    partialContent: 206, 
    accepted: 202, 
    nonAuthoritativeInformation: 203, 
    noContent: 204, 
    resetContent: 205, 
    ambiguous: 300, 
    moved: 301, 
    redirect: 302, 
    redirectMethod: 303, 
    notModified: 304, 
    useProxy: 305, 
    temporaryRedirect: 307, 
    badRequest: 400, 
    methodNotAllowed: 400, 
    unauthorized: 401, 
    paymentRequired: 402, 
    forbidden: 403, 
    notFound: 404, 
    notAcceptable: 406, 
    proxyAuthenticationRequired: 407, 
    requestTimeout: 408, 
    conflict: 409, 
    gone: 410, 
    lengthRequired: 411, 
    preconditionFailed: 412, 
    requestEntityTooLarge: 413, 
    requestUriTooLong: 414, 
    unsupportedMediaType: 415, 
    requestedRangeNotSatisfiable: 416, 
    expectationFailed: 417, 
    internalServerError: 500, 
    notImplemented: 501, 
    badGateway: 502, 
    serviceUnavailable: 503, 
    gatewayTimeout: 504, 
    httpVersionNotSupported: 505
}
ScriptFX.Net.HTTPStatusCode.createEnum('ScriptFX.Net.HTTPStatusCode', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPRequestState

ScriptFX.Net.HTTPRequestState = function() { };
ScriptFX.Net.HTTPRequestState.prototype = {
    inactive: 0, 
    inProgress: 1, 
    completed: 2, 
    aborted: 3, 
    timedOut: 4
}
ScriptFX.Net.HTTPRequestState.createEnum('ScriptFX.Net.HTTPRequestState', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPVerb

ScriptFX.Net.HTTPVerb = function() { };
ScriptFX.Net.HTTPVerb.prototype = {
    GET: 0, 
    POST: 1, 
    PUT: 2, 
    DELETE: 3
}
ScriptFX.Net.HTTPVerb.createEnum('ScriptFX.Net.HTTPVerb', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.IHTTPResponse

ScriptFX.Net.IHTTPResponse = function() { };
ScriptFX.Net.IHTTPResponse.prototype = {
    get_contentLength : null,
    get_contentType : null,
    get_headers : null,
    get_request : null,
    get_statusCode : null,
    get_statusText : null,
    get_timeStamp : null,
    getHeader : null,
    getObject : null,
    getText : null,
    getXML : null
}
ScriptFX.Net.IHTTPResponse.createInterface('ScriptFX.Net.IHTTPResponse');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPRequest

ScriptFX.Net.HTTPRequest = function ScriptFX_Net_HTTPRequest() {
}
ScriptFX.Net.HTTPRequest.createRequest = function ScriptFX_Net_HTTPRequest$createRequest(uri, verb) {
    Debug.assert(!String.isNullOrEmpty(uri));
    var request = new ScriptFX.Net.HTTPRequest();
    if (!uri.startsWith('{')) {
        request._uri = uri;
    }
    else {
        var uriData = ScriptFX.JSON.deserialize(uri);
        request._uri = uriData['__uri'];
        Debug.assert(!String.isNullOrEmpty(request._uri));
        if (uriData['__nullParams']) {
            request._transportType = uriData['__transportType'];
        }
        else {
            request._transportType = Type.getType(uriData['__transportType']);
            delete uriData.__uri;
            delete uriData.__transportType;
            request._transportParameters = uriData;
        }
        Debug.assert((request._transportType) && ScriptFX.Net.HTTPTransport.isAssignableFrom(request._transportType));
    }
    request._verb = verb;
    return request;
}
ScriptFX.Net.HTTPRequest.createURI = function ScriptFX_Net_HTTPRequest$createURI(uri, parameters) {
    var sb = new StringBuilder(uri);
    if (uri.indexOf('?') < 0) {
        sb.append('?');
    }
    var parameterIndex = 0;
    var $dict1 = parameters;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        if (parameterIndex) {
            sb.append('&');
        }
        sb.append(entry.key);
        sb.append('=');
        sb.append(encodeURIComponent(entry.value.toString()));
        parameterIndex++;
    }
    return sb.toString();
}
ScriptFX.Net.HTTPRequest.prototype = {
    _uri: null,
    _verb: 0,
    _content: null,
    _headers: null,
    _userName: null,
    _password: null,
    _transportType: null,
    _transportParameters: null,
    _timeout: 0,
    _callback: null,
    _context: null,
    _state: 0,
    _transport: null,
    _response: null,
    _timeStamp: null,
    
    get_content: function ScriptFX_Net_HTTPRequest$get_content() {
        return this._content;
    },
    set_content: function ScriptFX_Net_HTTPRequest$set_content(value) {
        Debug.assert(this.get_verb() === ScriptFX.Net.HTTPVerb.POST);
        Debug.assert(this._state === ScriptFX.Net.HTTPRequestState.inactive);
        this._content = value;
        return value;
    },
    
    get_hasCredentials: function ScriptFX_Net_HTTPRequest$get_hasCredentials() {
        return (!String.isNullOrEmpty(this._userName));
    },
    
    get_hasHeaders: function ScriptFX_Net_HTTPRequest$get_hasHeaders() {
        return (this._headers);
    },
    
    get_headers: function ScriptFX_Net_HTTPRequest$get_headers() {
        if (!this._headers) {
            this._headers = {};
        }
        return this._headers;
    },
    
    get_password: function ScriptFX_Net_HTTPRequest$get_password() {
        return this._password;
    },
    
    get_response: function ScriptFX_Net_HTTPRequest$get_response() {
        Debug.assert(this._state === ScriptFX.Net.HTTPRequestState.completed);
        return this._response;
    },
    
    get_state: function ScriptFX_Net_HTTPRequest$get_state() {
        return this._state;
    },
    
    get_timeout: function ScriptFX_Net_HTTPRequest$get_timeout() {
        return this._timeout;
    },
    set_timeout: function ScriptFX_Net_HTTPRequest$set_timeout(value) {
        this._timeout = value;
        return value;
    },
    
    get_timeStamp: function ScriptFX_Net_HTTPRequest$get_timeStamp() {
        return this._timeStamp;
    },
    
    get__transport: function ScriptFX_Net_HTTPRequest$get__transport() {
        return this._transport;
    },
    
    get__transportParameters: function ScriptFX_Net_HTTPRequest$get__transportParameters() {
        return this._transportParameters;
    },
    
    get_transportType: function ScriptFX_Net_HTTPRequest$get_transportType() {
        return this._transportType;
    },
    
    get_URI: function ScriptFX_Net_HTTPRequest$get_URI() {
        return this._uri;
    },
    
    get_userName: function ScriptFX_Net_HTTPRequest$get_userName() {
        return this._userName;
    },
    
    get_verb: function ScriptFX_Net_HTTPRequest$get_verb() {
        return this._verb;
    },
    
    abort: function ScriptFX_Net_HTTPRequest$abort() {
        if (this._state === ScriptFX.Net.HTTPRequestState.inProgress) {
            ScriptFX.Net.HTTPRequestManager._abort(this, false);
        }
    },
    
    dispose: function ScriptFX_Net_HTTPRequest$dispose() {
        if (this._transport) {
            this.abort();
        }
    },
    
    invoke: function ScriptFX_Net_HTTPRequest$invoke(callback, context) {
        Debug.assert(this._state === ScriptFX.Net.HTTPRequestState.inactive);
        this._callback = callback;
        this._context = context;
        ScriptFX.Application.current.registerDisposableObject(this);
        ScriptFX.Net.HTTPRequestManager._beginInvoke(this);
    },
    
    _invokeCallback: function ScriptFX_Net_HTTPRequest$_invokeCallback() {
        ScriptFX.Application.current.unregisterDisposableObject(this);
        if (this._transport) {
            this._transport.dispose();
            this._transport = null;
        }
        if (this._callback) {
            this._callback.invoke(this, this._context);
            this._callback = null;
            this._context = null;
        }
    },
    
    _onAbort: function ScriptFX_Net_HTTPRequest$_onAbort() {
        this._state = ScriptFX.Net.HTTPRequestState.aborted;
        this._invokeCallback();
    },
    
    _onActivate: function ScriptFX_Net_HTTPRequest$_onActivate(transport) {
        this._transport = transport;
        this._state = ScriptFX.Net.HTTPRequestState.inProgress;
        this._timeStamp = new Date();
    },
    
    _onCompleted: function ScriptFX_Net_HTTPRequest$_onCompleted(response) {
        this._response = response;
        this._state = ScriptFX.Net.HTTPRequestState.completed;
        this._invokeCallback();
    },
    
    _onTimeout: function ScriptFX_Net_HTTPRequest$_onTimeout() {
        this._state = ScriptFX.Net.HTTPRequestState.timedOut;
        this._invokeCallback();
    },
    
    setContentAsForm: function ScriptFX_Net_HTTPRequest$setContentAsForm(data) {
        Debug.assert(data);
        this.get_headers()['Content-Type'] = 'application/x-www-form-urlencoded';
        var sb = new StringBuilder();
        var firstValue = true;
        var $dict1 = data;
        for (var $key2 in $dict1) {
            var e = { key: $key2, value: $dict1[$key2] };
            if (!firstValue) {
                sb.append('&');
            }
            sb.append(e.key);
            sb.append('=');
            sb.append(encodeURIComponent(e.value.toString()));
            firstValue = false;
        }
        this.set_content(sb.toString());
    },
    
    setContentAsJSON: function ScriptFX_Net_HTTPRequest$setContentAsJSON(data) {
        Debug.assert(data);
        this.get_headers()['Content-Type'] = 'text/json';
        this.set_content(ScriptFX.JSON.serialize(data));
    },
    
    setCredentials: function ScriptFX_Net_HTTPRequest$setCredentials(userName, password) {
        Debug.assert(!String.isNullOrEmpty(userName));
        Debug.assert(!String.isNullOrEmpty(password));
        this._userName = userName;
        this._password = password;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPRequestManager

ScriptFX.Net.HTTPRequestManager = function ScriptFX_Net_HTTPRequestManager() {
}
ScriptFX.Net.HTTPRequestManager.add_requestInvoking = function ScriptFX_Net_HTTPRequestManager$add_requestInvoking(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoking = Delegate.combine(ScriptFX.Net.HTTPRequestManager.__requestInvoking, value);
}
ScriptFX.Net.HTTPRequestManager.remove_requestInvoking = function ScriptFX_Net_HTTPRequestManager$remove_requestInvoking(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoking = Delegate.remove(ScriptFX.Net.HTTPRequestManager.__requestInvoking, value);
}
ScriptFX.Net.HTTPRequestManager.add_requestInvoked = function ScriptFX_Net_HTTPRequestManager$add_requestInvoked(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoked = Delegate.combine(ScriptFX.Net.HTTPRequestManager.__requestInvoked, value);
}
ScriptFX.Net.HTTPRequestManager.remove_requestInvoked = function ScriptFX_Net_HTTPRequestManager$remove_requestInvoked(value) {
    ScriptFX.Net.HTTPRequestManager.__requestInvoked = Delegate.remove(ScriptFX.Net.HTTPRequestManager.__requestInvoked, value);
}
ScriptFX.Net.HTTPRequestManager.get_online = function ScriptFX_Net_HTTPRequestManager$get_online() {
    return window.navigator.onLine;
}
ScriptFX.Net.HTTPRequestManager.get_timeoutInterval = function ScriptFX_Net_HTTPRequestManager$get_timeoutInterval() {
    return ScriptFX.Net.HTTPRequestManager._timeoutInterval;
}
ScriptFX.Net.HTTPRequestManager.set_timeoutInterval = function ScriptFX_Net_HTTPRequestManager$set_timeoutInterval(value) {
    ScriptFX.Net.HTTPRequestManager._timeoutInterval = value;
    return value;
}
ScriptFX.Net.HTTPRequestManager._abort = function ScriptFX_Net_HTTPRequestManager$_abort(request, timedOut) {
    var transport = request.get__transport();
    if (transport) {
        transport.abort();
        ScriptFX.Net.HTTPRequestManager._endInvoke(request, null, timedOut);
    }
}
ScriptFX.Net.HTTPRequestManager.abortAll = function ScriptFX_Net_HTTPRequestManager$abortAll() {
    var requests = ScriptFX.Net.HTTPRequestManager._activeRequests;
    ScriptFX.Net.HTTPRequestManager._activeRequests = [];
    var $enum1 = requests.getEnumerator();
    while ($enum1.moveNext()) {
        var request = $enum1.get_current();
        ScriptFX.Net.HTTPRequestManager._abort(request, false);
    }
}
ScriptFX.Net.HTTPRequestManager._beginInvoke = function ScriptFX_Net_HTTPRequestManager$_beginInvoke(request) {
    if (ScriptFX.Net.HTTPRequestManager.__requestInvoking) {
        var e = new ScriptFX.Net.PreHTTPRequestEventArgs(request);
        ScriptFX.Net.HTTPRequestManager.__requestInvoking.invoke(null, e);
        if (e.get_isSuppressed()) {
            request._onCompleted(e.get_response());
            return;
        }
    }
    var transportType = request.get_transportType();
    if (!transportType) {
        transportType = ScriptFX.Net._xmlhttpTransport;
    }
    var transport = new transportType(request);
    request._onActivate(transport);
    ScriptFX.Net.HTTPRequestManager._activeRequests.add(request);
    transport.invoke();
    if (((ScriptFX.Net.HTTPRequestManager._timeoutInterval) || (request.get_timeout())) && (!ScriptFX.Net.HTTPRequestManager._appIdleHandler)) {
        ScriptFX.Net.HTTPRequestManager._appIdleHandler = Delegate.create(null, ScriptFX.Net.HTTPRequestManager._onApplicationIdle);
        ScriptFX.Application.current.add_idle(ScriptFX.Net.HTTPRequestManager._appIdleHandler);
    }
}
ScriptFX.Net.HTTPRequestManager._endInvoke = function ScriptFX_Net_HTTPRequestManager$_endInvoke(request, response, timedOut) {
    ScriptFX.Net.HTTPRequestManager._activeRequests.remove(request);
    if (response) {
        request._onCompleted(response);
    }
    else if (timedOut) {
        request._onTimeout();
    }
    else {
        request._onAbort();
    }
    if (ScriptFX.Net.HTTPRequestManager.__requestInvoked) {
        var e = new ScriptFX.Net.PostHTTPRequestEventArgs(request, response);
        ScriptFX.Net.HTTPRequestManager.__requestInvoked.invoke(null, e);
    }
    if ((!ScriptFX.Net.HTTPRequestManager._activeRequests.length) && (ScriptFX.Net.HTTPRequestManager._appIdleHandler)) {
        ScriptFX.Application.current.remove_idle(ScriptFX.Net.HTTPRequestManager._appIdleHandler);
        ScriptFX.Net.HTTPRequestManager._appIdleHandler = null;
    }
}
ScriptFX.Net.HTTPRequestManager._onApplicationIdle = function ScriptFX_Net_HTTPRequestManager$_onApplicationIdle(sender, e) {
    if (!ScriptFX.Net.HTTPRequestManager._activeRequests.length) {
        return;
    }
    var timedOutRequests = null;
    var currentTimeValue = (new Date()).getTime();
    var $enum1 = ScriptFX.Net.HTTPRequestManager._activeRequests.getEnumerator();
    while ($enum1.moveNext()) {
        var request = $enum1.get_current();
        var timeStampValue = request.get_timeStamp().getTime();
        var interval = request.get_timeout();
        if (!interval) {
            interval = ScriptFX.Net.HTTPRequestManager._timeoutInterval;
            if (!interval) {
                continue;
            }
        }
        if ((currentTimeValue - timeStampValue) > interval) {
            if (!timedOutRequests) {
                timedOutRequests = [];
            }
            timedOutRequests.add(request);
        }
    }
    if (timedOutRequests) {
        var $enum2 = timedOutRequests.getEnumerator();
        while ($enum2.moveNext()) {
            var request = $enum2.get_current();
            ScriptFX.Net.HTTPRequestManager._abort(request, true);
        }
    }
}
ScriptFX.Net.HTTPRequestManager._onCompleted = function ScriptFX_Net_HTTPRequestManager$_onCompleted(request, response) {
    ScriptFX.Net.HTTPRequestManager._endInvoke(request, response, false);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.HTTPTransport

ScriptFX.Net.HTTPTransport = function ScriptFX_Net_HTTPTransport(request) {
    this._request = request;
}
ScriptFX.Net.HTTPTransport.createURI = function ScriptFX_Net_HTTPTransport$createURI(uri, transportType, parameters) {
    Debug.assert(!String.isNullOrEmpty(uri));
    Debug.assert((transportType) && ScriptFX.Net.HTTPTransport.isAssignableFrom(transportType));
    if (!parameters) {
        return '{__nullParams: true, __uri:\'' + uri + '\', __transportType: ' + transportType.get_fullName() + '}';
    }
    else {
        parameters['__uri'] = uri;
        parameters['__transportType'] = transportType.get_fullName();
        return ScriptFX.JSON.serialize(parameters);
    }
}
ScriptFX.Net.HTTPTransport.prototype = {
    _request: null,
    
    get_parameters: function ScriptFX_Net_HTTPTransport$get_parameters() {
        return this._request.get__transportParameters();
    },
    
    get_request: function ScriptFX_Net_HTTPTransport$get_request() {
        return this._request;
    },
    
    getMethod: function ScriptFX_Net_HTTPTransport$getMethod() {
        return Enum.toString(ScriptFX.Net.HTTPVerb, this._request.get_verb());
    },
    
    onCompleted: function ScriptFX_Net_HTTPTransport$onCompleted(response) {
        ScriptFX.Net.HTTPRequestManager._onCompleted(this._request, response);
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.PostHTTPRequestEventArgs

ScriptFX.Net.PostHTTPRequestEventArgs = function ScriptFX_Net_PostHTTPRequestEventArgs(request, response) {
    ScriptFX.Net.PostHTTPRequestEventArgs.constructBase(this);
    this._request$1 = request;
    this._response$1 = response;
}
ScriptFX.Net.PostHTTPRequestEventArgs.prototype = {
    _request$1: null,
    _response$1: null,
    
    get_request: function ScriptFX_Net_PostHTTPRequestEventArgs$get_request() {
        return this._request$1;
    },
    
    get_response: function ScriptFX_Net_PostHTTPRequestEventArgs$get_response() {
        return this._response$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.PreHTTPRequestEventArgs

ScriptFX.Net.PreHTTPRequestEventArgs = function ScriptFX_Net_PreHTTPRequestEventArgs(request) {
    ScriptFX.Net.PreHTTPRequestEventArgs.constructBase(this);
    this._request$1 = request;
}
ScriptFX.Net.PreHTTPRequestEventArgs.prototype = {
    _request$1: null,
    _response$1: null,
    _suppressed$1: false,
    
    get_isSuppressed: function ScriptFX_Net_PreHTTPRequestEventArgs$get_isSuppressed() {
        return this._suppressed$1;
    },
    
    get_request: function ScriptFX_Net_PreHTTPRequestEventArgs$get_request() {
        return this._request$1;
    },
    
    get_response: function ScriptFX_Net_PreHTTPRequestEventArgs$get_response() {
        return this._response$1;
    },
    
    suppressRequest: function ScriptFX_Net_PreHTTPRequestEventArgs$suppressRequest(response) {
        this._suppressed$1 = true;
        this._response$1 = response;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net._xmlhttpResponse

ScriptFX.Net._xmlhttpResponse = function ScriptFX_Net__xmlhttpResponse(request, xmlHTTP) {
    this._timeStamp = new Date();
    this._request = request;
    this._xmlHTTP = xmlHTTP;
}
ScriptFX.Net._xmlhttpResponse.prototype = {
    _request: null,
    _xmlHTTP: null,
    _headers: null,
    _timeStamp: null,
    _text: null,
    _object: null,
    _xml: null,
    
    get_contentLength: function ScriptFX_Net__xmlhttpResponse$get_contentLength() {
        return this.getText().length;
    },
    
    get_contentType: function ScriptFX_Net__xmlhttpResponse$get_contentType() {
        return this._xmlHTTP.getResponseHeader('Content-Type');
    },
    
    get_headers: function ScriptFX_Net__xmlhttpResponse$get_headers() {
        if (!this._headers) {
            var headers = this._xmlHTTP.getAllResponseHeaders();
            var parts = headers.split('\n');
            this._headers = {};
            var $enum1 = parts.getEnumerator();
            while ($enum1.moveNext()) {
                var part = $enum1.get_current();
                var colonIndex = part.indexOf(':');
                this._headers[part.substr(0, colonIndex)] = part.substr(colonIndex + 1).trim();
            }
        }
        return this._headers;
    },
    
    get_request: function ScriptFX_Net__xmlhttpResponse$get_request() {
        return this._request;
    },
    
    get_statusCode: function ScriptFX_Net__xmlhttpResponse$get_statusCode() {
        return this._xmlHTTP.status;
    },
    
    get_statusText: function ScriptFX_Net__xmlhttpResponse$get_statusText() {
        return this._xmlHTTP.statusText;
    },
    
    get_timeStamp: function ScriptFX_Net__xmlhttpResponse$get_timeStamp() {
        return this._timeStamp;
    },
    
    getHeader: function ScriptFX_Net__xmlhttpResponse$getHeader(name) {
        return this._xmlHTTP.getResponseHeader(name);
    },
    
    getObject: function ScriptFX_Net__xmlhttpResponse$getObject() {
        if (!this._object) {
            this._object = ScriptFX.JSON.deserialize(this.getText());
        }
        return this._object;
    },
    
    getText: function ScriptFX_Net__xmlhttpResponse$getText() {
        if (!this._text) {
            this._text = this._xmlHTTP.responseText;
        }
        return this._text;
    },
    
    getXML: function ScriptFX_Net__xmlhttpResponse$getXML() {
        if (!this._xml) {
            var xml = this._xmlHTTP.responseXML;
            if ((!xml) || (!xml.documentElement)) {
                try {
                    xml = XMLDocumentParser.parse(this._xmlHTTP.responseText);
                    if ((xml) && (xml.documentElement)) {
                        this._xml = xml;
                    }
                }
                catch ($e1) {
                }
            }
            else {
                this._xml = xml;
                if (ScriptFX.Application.current.get_isIE()) {
                    xml.setProperty('SelectionLanguage', 'XPath');
                }
            }
        }
        return this._xml;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net._xmlhttpTransport

ScriptFX.Net._xmlhttpTransport = function ScriptFX_Net__xmlhttpTransport(request) {
    ScriptFX.Net._xmlhttpTransport.constructBase(this, [ request ]);
}
ScriptFX.Net._xmlhttpTransport.prototype = {
    _xmlHTTP$1: null,
    
    abort: function ScriptFX_Net__xmlhttpTransport$abort() {
        if (this._xmlHTTP$1) {
            this._xmlHTTP$1.onreadystatechange = Delegate.Null;
            this._xmlHTTP$1.abort();
            this._xmlHTTP$1 = null;
        }
    },
    
    dispose: function ScriptFX_Net__xmlhttpTransport$dispose() {
        this.abort();
    },
    
    invoke: function ScriptFX_Net__xmlhttpTransport$invoke() {
        var request = this.get_request();
        this._xmlHTTP$1 = new XMLHttpRequest();
        this._xmlHTTP$1.onreadystatechange = Delegate.create(this, this._onReadyStateChange$1);
        if (!this.get_request().get_hasCredentials()) {
            this._xmlHTTP$1.open(this.getMethod(), request.get_URI(), true);
        }
        else {
            this._xmlHTTP$1.open(this.getMethod(), request.get_URI(), true, request.get_userName(), request.get_password());
        }
        var headers = (request.get_hasHeaders()) ? request.get_headers() : null;
        if (headers) {
            var $dict1 = headers;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                this._xmlHTTP$1.setRequestHeader(entry.key, entry.value);
            }
        }
        var body = request.get_content();
        if ((body) && ((!headers) || (!headers['Content-Type']))) {
            this._xmlHTTP$1.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
        }
        this._xmlHTTP$1.send(body);
    },
    
    _onReadyStateChange$1: function ScriptFX_Net__xmlhttpTransport$_onReadyStateChange$1() {
        if (this._xmlHTTP$1.readyState === 4) {
            var response = new ScriptFX.Net._xmlhttpResponse(this.get_request(), this._xmlHTTP$1);
            this._xmlHTTP$1.onreadystatechange = Delegate.Null;
            this._xmlHTTP$1 = null;
            this.onCompleted(response);
        }
    }
}


Type.createNamespace('ScriptFX.UI');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AnimationStopState

ScriptFX.UI.AnimationStopState = function() { };
ScriptFX.UI.AnimationStopState.prototype = {
    complete: 0, 
    abort: 1, 
    revert: 2
}
ScriptFX.UI.AnimationStopState.createEnum('ScriptFX.UI.AnimationStopState', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Bounds

ScriptFX.UI.$create_Bounds = function ScriptFX_UI_Bounds(left, top, width, height) {
    var $o = { };
    $o.left = left;
    $o.top = top;
    $o.width = width;
    $o.height = height;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragDropData

ScriptFX.UI.$create_DragDropData = function ScriptFX_UI_DragDropData(mode, dataType, data) {
    var $o = { };
    $o.mode = mode;
    $o.dataType = dataType;
    $o.data = data;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragMode

ScriptFX.UI.DragMode = function() { };
ScriptFX.UI.DragMode.prototype = {
    move: 0, 
    copy: 1
}
ScriptFX.UI.DragMode.createEnum('ScriptFX.UI.DragMode', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IAction

ScriptFX.UI.IAction = function() { };
ScriptFX.UI.IAction.prototype = {
    get_actionArgument : null,
    get_actionName : null,
    add_action : null,
    remove_action : null
}
ScriptFX.UI.IAction.createInterface('ScriptFX.UI.IAction');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IDragDrop

ScriptFX.UI.IDragDrop = function() { };
ScriptFX.UI.IDragDrop.prototype = {
    get_supportsDataTransfer : null,
    dragDrop : null
}
ScriptFX.UI.IDragDrop.createInterface('ScriptFX.UI.IDragDrop');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IDragSource

ScriptFX.UI.IDragSource = function() { };
ScriptFX.UI.IDragSource.prototype = {
    get_domElement : null,
    onDragStart : null,
    onDrag : null,
    onDragEnd : null
}
ScriptFX.UI.IDragSource.createInterface('ScriptFX.UI.IDragSource');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IDropTarget

ScriptFX.UI.IDropTarget = function() { };
ScriptFX.UI.IDropTarget.prototype = {
    get_domElement : null,
    supportsDataObject : null,
    drop : null,
    onDragEnter : null,
    onDragLeave : null,
    onDragOver : null
}
ScriptFX.UI.IDropTarget.createInterface('ScriptFX.UI.IDropTarget');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IEditableText

ScriptFX.UI.IEditableText = function() { };
ScriptFX.UI.IEditableText.prototype = {
    get_text : null,
    set_text : null,
    add_textChanged : null,
    remove_textChanged : null
}
ScriptFX.UI.IEditableText.createInterface('ScriptFX.UI.IEditableText');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IStaticText

ScriptFX.UI.IStaticText = function() { };
ScriptFX.UI.IStaticText.prototype = {
    get_text : null
}
ScriptFX.UI.IStaticText.createInterface('ScriptFX.UI.IStaticText');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IToggle

ScriptFX.UI.IToggle = function() { };
ScriptFX.UI.IToggle.prototype = {
    get_checked : null,
    add_checkedChanged : null,
    remove_checkedChanged : null
}
ScriptFX.UI.IToggle.createInterface('ScriptFX.UI.IToggle');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.IValidator

ScriptFX.UI.IValidator = function() { };
ScriptFX.UI.IValidator.prototype = {
    get_isValid : null,
    get_validationGroup : null
}
ScriptFX.UI.IValidator.createInterface('ScriptFX.UI.IValidator');


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Key

ScriptFX.UI.Key = function() { };
ScriptFX.UI.Key.prototype = {
    backspace: 8, 
    tab: 9, 
    enter: 13, 
    escape: 27, 
    space: 32, 
    pageUp: 33, 
    pageDown: 34, 
    end: 35, 
    home: 36, 
    left: 37, 
    up: 38, 
    right: 39, 
    down: 40, 
    del: 127
}
ScriptFX.UI.Key.createEnum('ScriptFX.UI.Key', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Location

ScriptFX.UI.$create_Location = function ScriptFX_UI_Location(left, top) {
    var $o = { };
    $o.left = left;
    $o.top = top;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.OverlayOptions

ScriptFX.UI.$create_OverlayOptions = function ScriptFX_UI_OverlayOptions(cssClass) {
    var $o = { };
    $o.cssClass = cssClass;
    $o.fadeInOutInterval = 250;
    $o.opacity = 0.75;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.PopupMode

ScriptFX.UI.PopupMode = function() { };
ScriptFX.UI.PopupMode.prototype = {
    center: 0, 
    anchorTopLeft: 1, 
    anchorTopRight: 2, 
    anchorBottomRight: 3, 
    anchorBottomLeft: 4, 
    alignTopLeft: 5, 
    alignTopRight: 6, 
    alignBottomRight: 7, 
    alignBottomLeft: 8
}
ScriptFX.UI.PopupMode.createEnum('ScriptFX.UI.PopupMode', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.PopupOptions

ScriptFX.UI.$create_PopupOptions = function ScriptFX_UI_PopupOptions(referenceElement, mode) {
    var $o = { };
    $o.referenceElement = referenceElement;
    $o.mode = mode;
    $o.id = null;
    $o.xOffset = 0;
    $o.yOffset = 0;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Size

ScriptFX.UI.$create_Size = function ScriptFX_UI_Size(width, height) {
    var $o = { };
    $o.width = width;
    $o.height = height;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Animation

ScriptFX.UI.Animation = function ScriptFX_UI_Animation(domElement) {
    if (!domElement) {
        domElement = document.documentElement;
    }
    this._domElement = domElement;
    this._repeatCount = 1;
    ScriptFX.Application.current.registerDisposableObject(this);
}
ScriptFX.UI.Animation.prototype = {
    _domElement: null,
    _repeatCount: 0,
    _autoReverse: false,
    _repeatDelay: 0,
    _completed: false,
    _isPlaying: false,
    _isRepeating: false,
    _repetitions: 0,
    _repeatTimeStamp: 0,
    _reversed: false,
    
    add_repeating: function ScriptFX_UI_Animation$add_repeating(value) {
        this.__repeating = Delegate.combine(this.__repeating, value);
    },
    remove_repeating: function ScriptFX_UI_Animation$remove_repeating(value) {
        this.__repeating = Delegate.remove(this.__repeating, value);
    },
    
    __repeating: null,
    
    add_starting: function ScriptFX_UI_Animation$add_starting(value) {
        this.__starting = Delegate.combine(this.__starting, value);
    },
    remove_starting: function ScriptFX_UI_Animation$remove_starting(value) {
        this.__starting = Delegate.remove(this.__starting, value);
    },
    
    __starting: null,
    
    add_stopped: function ScriptFX_UI_Animation$add_stopped(value) {
        this.__stopped = Delegate.combine(this.__stopped, value);
    },
    remove_stopped: function ScriptFX_UI_Animation$remove_stopped(value) {
        this.__stopped = Delegate.remove(this.__stopped, value);
    },
    
    __stopped: null,
    
    get_autoReverse: function ScriptFX_UI_Animation$get_autoReverse() {
        return this._autoReverse;
    },
    set_autoReverse: function ScriptFX_UI_Animation$set_autoReverse(value) {
        Debug.assert(!this.get_isPlaying());
        this._autoReverse = value;
        return value;
    },
    
    get_completed: function ScriptFX_UI_Animation$get_completed() {
        return this._completed;
    },
    
    get_domElement: function ScriptFX_UI_Animation$get_domElement() {
        return this._domElement;
    },
    
    get_isPlaying: function ScriptFX_UI_Animation$get_isPlaying() {
        return this._isPlaying;
    },
    
    get_isReversed: function ScriptFX_UI_Animation$get_isReversed() {
        return this._reversed;
    },
    
    get_repeatCount: function ScriptFX_UI_Animation$get_repeatCount() {
        return this._repeatCount;
    },
    set_repeatCount: function ScriptFX_UI_Animation$set_repeatCount(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(value >= 0);
        this._repeatCount = value;
        return value;
    },
    
    get_repeatDelay: function ScriptFX_UI_Animation$get_repeatDelay() {
        return this._repeatDelay;
    },
    set_repeatDelay: function ScriptFX_UI_Animation$set_repeatDelay(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(value >= 0);
        this._repeatDelay = value;
        return value;
    },
    
    get_repetitions: function ScriptFX_UI_Animation$get_repetitions() {
        return this._repetitions;
    },
    
    dispose: function ScriptFX_UI_Animation$dispose() {
        if (this._isPlaying) {
            this.stop(ScriptFX.UI.AnimationStopState.abort);
        }
        if (this._domElement) {
            this._domElement = null;
            ScriptFX.Application.current.unregisterDisposableObject(this);
        }
    },
    
    _onPlay: function ScriptFX_UI_Animation$_onPlay(reversed) {
        if (this.__starting) {
            this.__starting.invoke(this, EventArgs.Empty);
        }
        this.performSetup();
        this._isPlaying = true;
        this._repetitions = 1;
        this._reversed = reversed;
        this.playCore();
    },
    
    _onStop: function ScriptFX_UI_Animation$_onStop(completed, stopState) {
        this.stopCore(completed, stopState);
        this._completed = completed;
        this._isPlaying = false;
        this.performCleanup();
        if (this.__stopped) {
            this.__stopped.invoke(this, EventArgs.Empty);
        }
    },
    
    _onProgress: function ScriptFX_UI_Animation$_onProgress(timeStamp) {
        if (this._isRepeating) {
            if ((this._repeatDelay) && ((this._repeatTimeStamp + this._repeatDelay) > timeStamp)) {
                return false;
            }
        }
        var completed = this.progressCore(this._isRepeating, timeStamp);
        this._isRepeating = false;
        if (completed && ((!this._repeatCount) || (this._repeatCount > this._repetitions))) {
            completed = false;
            this._repetitions++;
            if (this.__repeating) {
                var ce = new ScriptFX.CancelEventArgs();
                this.__repeating.invoke(this, ce);
                completed = ce.get_canceled();
            }
            if (!completed) {
                this._isRepeating = true;
                if (this._autoReverse) {
                    this._reversed = !this._reversed;
                }
                this._repeatTimeStamp = timeStamp;
                this.performRepetition(this._reversed);
            }
        }
        return completed;
    },
    
    performCleanup: function ScriptFX_UI_Animation$performCleanup() {
    },
    
    performRepetition: function ScriptFX_UI_Animation$performRepetition(reversed) {
    },
    
    performSetup: function ScriptFX_UI_Animation$performSetup() {
    },
    
    play: function ScriptFX_UI_Animation$play() {
        Debug.assert(!this.get_isPlaying());
        this._completed = false;
        ScriptFX.UI.AnimationManager._play(this);
    },
    
    stop: function ScriptFX_UI_Animation$stop(stopState) {
        Debug.assert(this.get_isPlaying());
        ScriptFX.UI.AnimationManager._stop(this, stopState);
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AnimationManager

ScriptFX.UI.AnimationManager = function ScriptFX_UI_AnimationManager() {
}
ScriptFX.UI.AnimationManager.get_FPS = function ScriptFX_UI_AnimationManager$get_FPS() {
    return ScriptFX.UI.AnimationManager._fps;
}
ScriptFX.UI.AnimationManager.set_FPS = function ScriptFX_UI_AnimationManager$set_FPS(value) {
    Debug.assert((value > 0) && (value <= 100));
    ScriptFX.UI.AnimationManager._fps = value;
    return value;
}
ScriptFX.UI.AnimationManager._onTick = function ScriptFX_UI_AnimationManager$_onTick() {
    ScriptFX.UI.AnimationManager._timerCookie = 0;
    if (!ScriptFX.UI.AnimationManager._activeAnimations.length) {
        return;
    }
    var timeStamp = (new Date()).getTime();
    var currentAnimations = ScriptFX.UI.AnimationManager._activeAnimations;
    var newAnimations = [];
    ScriptFX.UI.AnimationManager._activeAnimations = null;
    var $enum1 = currentAnimations.getEnumerator();
    while ($enum1.moveNext()) {
        var animation = $enum1.get_current();
        var completed = animation._onProgress(timeStamp);
        if (completed) {
            animation._onStop(true, ScriptFX.UI.AnimationStopState.complete);
        }
        else {
            newAnimations.add(animation);
        }
    }
    if (newAnimations.length) {
        ScriptFX.UI.AnimationManager._activeAnimations = newAnimations;
        if (!ScriptFX.UI.AnimationManager._timerCookie) {
            ScriptFX.UI.AnimationManager._timerCookie = window.setTimeout(Delegate.create(null, ScriptFX.UI.AnimationManager._onTick), 1000 / ScriptFX.UI.AnimationManager._fps);
        }
    }
}
ScriptFX.UI.AnimationManager._play = function ScriptFX_UI_AnimationManager$_play(animation) {
    if (!ScriptFX.UI.AnimationManager._activeAnimations) {
        ScriptFX.UI.AnimationManager._activeAnimations = [];
    }
    ScriptFX.UI.AnimationManager._activeAnimations.add(animation);
    animation._onPlay(false);
    if (!ScriptFX.UI.AnimationManager._timerCookie) {
        ScriptFX.UI.AnimationManager._timerCookie = window.setTimeout(Delegate.create(null, ScriptFX.UI.AnimationManager._onTick), 1000 / ScriptFX.UI.AnimationManager._fps);
    }
}
ScriptFX.UI.AnimationManager._stop = function ScriptFX_UI_AnimationManager$_stop(animation, stopState) {
    Debug.assert(ScriptFX.UI.AnimationManager._activeAnimations);
    animation._onStop(false, stopState);
    ScriptFX.UI.AnimationManager._activeAnimations.remove(animation);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AnimationSequence

ScriptFX.UI.AnimationSequence = function ScriptFX_UI_AnimationSequence(animations) {
    ScriptFX.UI.AnimationSequence.constructBase(this, [ null ]);
    Debug.assert((animations) && (animations.length > 1));
    this._animations$1 = animations;
    this._current$1 = -1;
}
ScriptFX.UI.AnimationSequence.prototype = {
    _animations$1: null,
    _successionDelay$1: 0,
    _current$1: 0,
    _nextAnimation$1: false,
    _successionTimeStamp$1: 0,
    
    get_successionDelay: function ScriptFX_UI_AnimationSequence$get_successionDelay() {
        return this._successionDelay$1;
    },
    set_successionDelay: function ScriptFX_UI_AnimationSequence$set_successionDelay(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(value >= 0);
        this._successionDelay$1 = value;
        return value;
    },
    
    playCore: function ScriptFX_UI_AnimationSequence$playCore() {
        Debug.assert(this._current$1 === -1);
        if (!this.get_isReversed()) {
            this._current$1 = 0;
        }
        else {
            this._current$1 = this._animations$1.length - 1;
        }
        this._animations$1[this._current$1]._onPlay(this.get_isReversed());
    },
    
    progressCore: function ScriptFX_UI_AnimationSequence$progressCore(startRepetition, timeStamp) {
        if (startRepetition) {
            if (!this.get_isReversed()) {
                this._current$1 = 0;
            }
            else {
                this._current$1 = this._animations$1.length - 1;
            }
            this._nextAnimation$1 = true;
        }
        var animation = this._animations$1[this._current$1];
        if (this._nextAnimation$1) {
            if ((this._successionDelay$1) && ((this._successionTimeStamp$1 + this._successionDelay$1) > timeStamp)) {
                return false;
            }
            this._nextAnimation$1 = false;
            animation._onPlay(this.get_isReversed());
        }
        var completed = animation._onProgress(timeStamp);
        if (completed) {
            animation._onStop(true, ScriptFX.UI.AnimationStopState.complete);
            if (!this.get_isReversed()) {
                this._current$1++;
            }
            else {
                this._current$1--;
            }
            this._nextAnimation$1 = true;
            this._successionTimeStamp$1 = timeStamp;
        }
        return completed && ((this._current$1 === this._animations$1.length) || (this._current$1 === -1));
    },
    
    stopCore: function ScriptFX_UI_AnimationSequence$stopCore(completed, stopState) {
        if (!completed) {
            var animation = this._animations$1[this._current$1];
            animation._onStop(false, stopState);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Behavior

ScriptFX.UI.Behavior = function ScriptFX_UI_Behavior(domElement, id) {
    Debug.assert(domElement);
    ScriptFX.Application.current.registerDisposableObject(this);
    this._domElement = domElement;
    this._id = id;
    if (!String.isNullOrEmpty(id)) {
        if (id === 'control') {
            var existingControl = domElement[id];
            if ((existingControl) && (Type.getInstanceType(existingControl) === ScriptFX.UI._genericControl)) {
                delete domElement.control;
                ScriptFX.Application.current.unregisterDisposableObject(existingControl);
                this._events = existingControl.get__eventsInternal();
            }
        }
        Debug.assert(isUndefined(domElement[id]));
        domElement[id] = this;
    }
    if (id !== 'control') {
        var existingControl = domElement.control;
        if (!existingControl) {
            existingControl = new ScriptFX.UI._genericControl(domElement);
        }
    }
    var behaviors = domElement._behaviors;
    if (!behaviors) {
        behaviors = [];
        domElement._behaviors = behaviors;
    }
    behaviors.add(this);
}
ScriptFX.UI.Behavior.getBehavior = function ScriptFX_UI_Behavior$getBehavior(domElement, type) {
    Debug.assert(domElement);
    Debug.assert(type);
    var behaviors = domElement._behaviors;
    if (behaviors) {
        var $enum1 = behaviors.getEnumerator();
        while ($enum1.moveNext()) {
            var behavior = $enum1.get_current();
            if (type.isAssignableFrom(Type.getInstanceType(behavior))) {
                return behavior;
            }
        }
    }
    return null;
}
ScriptFX.UI.Behavior.getBehaviors = function ScriptFX_UI_Behavior$getBehaviors(domElement, type) {
    Debug.assert(domElement);
    var behaviors = domElement._behaviors;
    if (isNullOrUndefined(behaviors) || (!behaviors.length)) {
        return null;
    }
    if (!type) {
        return behaviors.clone();
    }
    return behaviors.filter(Delegate.create(null, function(behavior) {
        return type.isAssignableFrom(Type.getInstanceType(behavior));
    }));
}
ScriptFX.UI.Behavior.getNamedBehavior = function ScriptFX_UI_Behavior$getNamedBehavior(domElement, id) {
    Debug.assert(domElement);
    Debug.assert(!String.isNullOrEmpty(id));
    return domElement[id];
}
ScriptFX.UI.Behavior.prototype = {
    _domElement: null,
    _id: null,
    _domEvents: null,
    _events: null,
    _initializing: false,
    
    get_domElement: function ScriptFX_UI_Behavior$get_domElement() {
        return this._domElement;
    },
    
    get_domEvents: function ScriptFX_UI_Behavior$get_domEvents() {
        if (!this._domEvents) {
            this._domEvents = new ScriptFX.UI.DOMEventList(this._domElement);
        }
        return this._domEvents;
    },
    
    get_events: function ScriptFX_UI_Behavior$get_events() {
        if (!this._events) {
            this._events = new ScriptFX.EventList();
        }
        return this._events;
    },
    
    get__eventsInternal: function ScriptFX_UI_Behavior$get__eventsInternal() {
        return this._events;
    },
    
    get_isDisposed: function ScriptFX_UI_Behavior$get_isDisposed() {
        return (!this._domElement);
    },
    
    get_isInitializing: function ScriptFX_UI_Behavior$get_isInitializing() {
        return this._initializing;
    },
    
    add_propertyChanged: function ScriptFX_UI_Behavior$add_propertyChanged(value) {
        this.get_events().addHandler('PropertyChanged', value);
    },
    remove_propertyChanged: function ScriptFX_UI_Behavior$remove_propertyChanged(value) {
        this.get_events().removeHandler('PropertyChanged', value);
    },
    
    beginInitialize: function ScriptFX_UI_Behavior$beginInitialize() {
        this._initializing = true;
    },
    
    dispose: function ScriptFX_UI_Behavior$dispose() {
        if (this._domEvents) {
            this._domEvents.dispose();
        }
        if (this._domElement) {
            if (this._id) {
                if (ScriptFX.Application.current.get_isIE()) {
                    this._domElement.removeAttribute(this._id);
                }
                else {
                    delete this._domElement[this._id];
                }
            }
            var behaviors = this._domElement._behaviors;
            Debug.assert(behaviors);
            behaviors.remove(this);
            this._domElement = null;
            ScriptFX.Application.current.unregisterDisposableObject(this);
        }
    },
    
    endInitialize: function ScriptFX_UI_Behavior$endInitialize() {
        this._initializing = false;
    },
    
    raisePropertyChanged: function ScriptFX_UI_Behavior$raisePropertyChanged(propertyName) {
        var propChangedHandler = this.get_events().getHandler('PropertyChanged');
        if (propChangedHandler) {
            propChangedHandler.invoke(this, new ScriptFX.PropertyChangedEventArgs(propertyName));
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Color

ScriptFX.UI.Color = function ScriptFX_UI_Color(red, green, blue) {
    Debug.assert(red >= 0 && red <= 255);
    Debug.assert(green >= 0 && green <= 255);
    Debug.assert(blue >= 0 && blue <= 255);
    this._red = red;
    this._green = green;
    this._blue = blue;
}
ScriptFX.UI.Color.format = function ScriptFX_UI_Color$format(red, green, blue) {
    return String.format('#{0:X2}{1:X2}{2:X2}', red, green, blue);
}
ScriptFX.UI.Color.parse = function ScriptFX_UI_Color$parse(s) {
    if (String.isNullOrEmpty(s)) {
        return null;
    }
    if ((s.length === 7) && s.startsWith('#')) {
        var red = parseInt(s.substr(1, 2), 16);
        var green = parseInt(s.substr(3, 2), 16);
        var blue = parseInt(s.substr(5, 2), 16);
        return new ScriptFX.UI.Color(red, green, blue);
    }
    else if (s.startsWith('rgb(') && s.endsWith(')')) {
        var parts = s.substring(4, s.length - 1).split(',');
        if (parts.length === 3) {
            return new ScriptFX.UI.Color(parseInt(parts[0].trim()), parseInt(parts[1].trim()), parseInt(parts[2].trim()));
        }
    }
    return null;
}
ScriptFX.UI.Color.prototype = {
    _red: 0,
    _green: 0,
    _blue: 0,
    
    get_blue: function ScriptFX_UI_Color$get_blue() {
        return this._blue;
    },
    
    get_green: function ScriptFX_UI_Color$get_green() {
        return this._green;
    },
    
    get_red: function ScriptFX_UI_Color$get_red() {
        return this._red;
    },
    
    toString: function ScriptFX_UI_Color$toString() {
        return ScriptFX.UI.Color.format(this._red, this._green, this._blue);
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Control

ScriptFX.UI.Control = function ScriptFX_UI_Control(domElement) {
    ScriptFX.UI.Control.constructBase(this, [ domElement, 'control' ]);
}
ScriptFX.UI.Control.getControl = function ScriptFX_UI_Control$getControl(domElement) {
    return ScriptFX.UI.Behavior.getNamedBehavior(domElement, 'control');
}
ScriptFX.UI.Control.prototype = {
    
    add_disposing: function ScriptFX_UI_Control$add_disposing(value) {
        this.get_events().addHandler('disposing', value);
    },
    remove_disposing: function ScriptFX_UI_Control$remove_disposing(value) {
        this.get_events().removeHandler('disposing', value);
    },
    
    dispose: function ScriptFX_UI_Control$dispose() {
        var element = this.get_domElement();
        if (element) {
            var disposingHandler = this.get_events().getHandler('disposing');
            if (disposingHandler) {
                disposingHandler.invoke(this, EventArgs.Empty);
            }
            var behaviors = ScriptFX.UI.Behavior.getBehaviors(element, null);
            Debug.assert((behaviors) && (behaviors.length > 0));
            if (behaviors.length > 1) {
                var $enum1 = behaviors.getEnumerator();
                while ($enum1.moveNext()) {
                    var behavior = $enum1.get_current();
                    if (behavior !== this) {
                        behavior.dispose();
                    }
                }
            }
        }
        ScriptFX.UI.Control.callBase(this, 'dispose');
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DOMEventList

ScriptFX.UI.DOMEventList = function ScriptFX_UI_DOMEventList(element) {
    Debug.assert(element);
    this._element = element;
    this._handlers = {};
}
ScriptFX.UI.DOMEventList.prototype = {
    _element: null,
    _handlers: null,
    
    attach: function ScriptFX_UI_DOMEventList$attach(eventName, handler) {
        Debug.assert(this._element);
        Debug.assert(!String.isNullOrEmpty(eventName));
        Debug.assert(handler);
        Debug.assert(!this.isAttached(eventName));
        this._element.attachEvent(eventName, handler);
        this._handlers[eventName] = handler;
    },
    
    detach: function ScriptFX_UI_DOMEventList$detach(eventName) {
        Debug.assert(this._element);
        Debug.assert(!String.isNullOrEmpty(eventName));
        var handler = this._handlers[eventName];
        if (handler) {
            this._element.detachEvent(eventName, handler);
            delete this._handlers[eventName];
            return true;
        }
        return false;
    },
    
    dispose: function ScriptFX_UI_DOMEventList$dispose() {
        if (this._element) {
            var $dict1 = this._handlers;
            for (var $key2 in $dict1) {
                var e = { key: $key2, value: $dict1[$key2] };
                this._element.detachEvent(e.key, e.value);
            }
            this._element = null;
            this._handlers = null;
        }
    },
    
    isAttached: function ScriptFX_UI_DOMEventList$isAttached(eventName) {
        Debug.assert(this._element);
        Debug.assert(!String.isNullOrEmpty(eventName));
        return (this._handlers[eventName]) ? true : false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragDropEventArgs

ScriptFX.UI.DragDropEventArgs = function ScriptFX_UI_DragDropEventArgs(dataObject) {
    ScriptFX.UI.DragDropEventArgs.constructBase(this);
    this._dataObject$1 = dataObject;
}
ScriptFX.UI.DragDropEventArgs.prototype = {
    _dataObject$1: null,
    
    get_dataObject: function ScriptFX_UI_DragDropEventArgs$get_dataObject() {
        return this._dataObject$1;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.DragDropManager

ScriptFX.UI.DragDropManager = function ScriptFX_UI_DragDropManager() {
}
ScriptFX.UI.DragDropManager.get_canDragDrop = function ScriptFX_UI_DragDropManager$get_canDragDrop() {
    return (ScriptFX.UI.DragDropManager._dragDropImplementation);
}
ScriptFX.UI.DragDropManager.get_supportsDataTransfer = function ScriptFX_UI_DragDropManager$get_supportsDataTransfer() {
    Debug.assert(ScriptFX.UI.DragDropManager.get_canDragDrop());
    return ScriptFX.UI.DragDropManager._dragDropImplementation.get_supportsDataTransfer();
}
ScriptFX.UI.DragDropManager.add_dragDropEnding = function ScriptFX_UI_DragDropManager$add_dragDropEnding(value) {
    ScriptFX.UI.DragDropManager._dragEndingHandler = Delegate.combine(ScriptFX.UI.DragDropManager._dragEndingHandler, value);
}
ScriptFX.UI.DragDropManager.remove_dragDropEnding = function ScriptFX_UI_DragDropManager$remove_dragDropEnding(value) {
    ScriptFX.UI.DragDropManager._dragEndingHandler = Delegate.remove(ScriptFX.UI.DragDropManager._dragEndingHandler, value);
}
ScriptFX.UI.DragDropManager.add_dragDropStarting = function ScriptFX_UI_DragDropManager$add_dragDropStarting(value) {
    ScriptFX.UI.DragDropManager._dragStartingHandler = Delegate.combine(ScriptFX.UI.DragDropManager._dragStartingHandler, value);
}
ScriptFX.UI.DragDropManager.remove_dragDropStarting = function ScriptFX_UI_DragDropManager$remove_dragDropStarting(value) {
    ScriptFX.UI.DragDropManager._dragStartingHandler = Delegate.remove(ScriptFX.UI.DragDropManager._dragStartingHandler, value);
}
ScriptFX.UI.DragDropManager._endDragDrop = function ScriptFX_UI_DragDropManager$_endDragDrop() {
    if (ScriptFX.UI.DragDropManager._dragEndingHandler) {
        ScriptFX.UI.DragDropManager._dragEndingHandler.invoke(null, new ScriptFX.UI.DragDropEventArgs(ScriptFX.UI.DragDropManager._currentDataObject));
    }
    ScriptFX.UI.DragDropManager._currentDataObject = null;
}
ScriptFX.UI.DragDropManager.registerDragDropImplementation = function ScriptFX_UI_DragDropManager$registerDragDropImplementation(dragDrop) {
    ScriptFX.UI.DragDropManager._dragDropImplementation = dragDrop;
}
ScriptFX.UI.DragDropManager.registerDropTarget = function ScriptFX_UI_DragDropManager$registerDropTarget(target) {
    ScriptFX.UI.DragDropManager._dropTargets.add(target);
}
ScriptFX.UI.DragDropManager.startDragDrop = function ScriptFX_UI_DragDropManager$startDragDrop(data, dragVisual, dragOffset, source, context) {
    Debug.assert(ScriptFX.UI.DragDropManager.get_canDragDrop());
    if (ScriptFX.UI.DragDropManager._currentDataObject) {
        return false;
    }
    var validDropTargets = [];
    var $enum1 = ScriptFX.UI.DragDropManager._dropTargets.getEnumerator();
    while ($enum1.moveNext()) {
        var dropTarget = $enum1.get_current();
        if (dropTarget.supportsDataObject(data)) {
            validDropTargets.add(dropTarget);
        }
    }
    if (!validDropTargets.length) {
        return false;
    }
    ScriptFX.UI.DragDropManager._currentDataObject = data;
    if (ScriptFX.UI.DragDropManager._dragStartingHandler) {
        ScriptFX.UI.DragDropManager._dragStartingHandler.invoke(null, new ScriptFX.UI.DragDropEventArgs(data));
    }
    ScriptFX.UI.DragDropManager._dragDropImplementation.dragDrop(new ScriptFX.UI._dragDropTracker(source), context, validDropTargets, dragVisual, dragOffset, ScriptFX.UI.DragDropManager._currentDataObject);
    return true;
}
ScriptFX.UI.DragDropManager.unregisterDropTarget = function ScriptFX_UI_DragDropManager$unregisterDropTarget(target) {
    ScriptFX.UI.DragDropManager._dropTargets.remove(target);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI._dragDropTracker

ScriptFX.UI._dragDropTracker = function ScriptFX_UI__dragDropTracker(actualSource) {
    this._actualSource = actualSource;
}
ScriptFX.UI._dragDropTracker.prototype = {
    _actualSource: null,
    
    get_domElement: function ScriptFX_UI__dragDropTracker$get_domElement() {
        return this._actualSource.get_domElement();
    },
    
    onDragStart: function ScriptFX_UI__dragDropTracker$onDragStart(context) {
        if (this._actualSource) {
            this._actualSource.onDragStart(context);
        }
    },
    
    onDrag: function ScriptFX_UI__dragDropTracker$onDrag(context) {
        if (this._actualSource) {
            this._actualSource.onDrag(context);
        }
    },
    
    onDragEnd: function ScriptFX_UI__dragDropTracker$onDragEnd(canceled, context) {
        if (this._actualSource) {
            this._actualSource.onDragEnd(canceled, context);
        }
        ScriptFX.UI.DragDropManager._endDragDrop();
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Element

ScriptFX.UI.Element = function ScriptFX_UI_Element() {
}
ScriptFX.UI.Element.addCSSClass = function ScriptFX_UI_Element$addCSSClass(element, className) {
    var cssClass = element.className;
    if ((' ' + cssClass + ' ').indexOf(' ' + className + ' ') < 0) {
        element.className = cssClass + ' ' + className;
    }
}
ScriptFX.UI.Element.containsCSSClass = function ScriptFX_UI_Element$containsCSSClass(element, className) {
    return element.className.split(' ').contains(className);
}
ScriptFX.UI.Element.getBounds = function ScriptFX_UI_Element$getBounds(element) {
    var location = ScriptFX.UI.Element.getLocation(element);
    return ScriptFX.UI.$create_Bounds(location.left, location.top, element.offsetWidth, element.offsetHeight);
}
ScriptFX.UI.Element.getLocation = function ScriptFX_UI_Element$getLocation(element) {
    var offsetX = 0;
    var offsetY = 0;
    for (var parentElement = element; parentElement; parentElement = parentElement.offsetParent) {
        offsetX += parentElement.offsetLeft;
        offsetY += parentElement.offsetTop;
    }
    return ScriptFX.UI.$create_Location(offsetX, offsetY);
}
ScriptFX.UI.Element.getSize = function ScriptFX_UI_Element$getSize(element) {
    return ScriptFX.UI.$create_Size(element.offsetWidth, element.offsetHeight);
}
ScriptFX.UI.Element.removeCSSClass = function ScriptFX_UI_Element$removeCSSClass(element, className) {
    var cssClass = ' ' + element.className + ' ';
    var index = cssClass.indexOf(' ' + className + ' ');
    if (index >= 0) {
        var newClass = cssClass.substr(0, index) + ' ' + cssClass.substr(index + className.length + 1);
        element.className = newClass;
    }
}
ScriptFX.UI.Element.setLocation = function ScriptFX_UI_Element$setLocation(element, location) {
    element.style.left = location.left + 'px';
    element.style.top = location.top + 'px';
}
ScriptFX.UI.Element.setSize = function ScriptFX_UI_Element$setSize(element, size) {
    element.style.width = size.width + 'px';
    element.style.height = size.height + 'px';
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.FadeEffect

ScriptFX.UI.FadeEffect = function ScriptFX_UI_FadeEffect(domElement, duration, opacity) {
    ScriptFX.UI.FadeEffect.constructBase(this, [ domElement, duration ]);
    this._opacity$2 = opacity;
}
ScriptFX.UI.FadeEffect.prototype = {
    _fadingIn$2: false,
    _opacity$2: 0,
    
    get_isFadingIn: function ScriptFX_UI_FadeEffect$get_isFadingIn() {
        return this._fadingIn$2;
    },
    
    fadeIn: function ScriptFX_UI_FadeEffect$fadeIn() {
        if (this.get_isPlaying()) {
            this.stop(ScriptFX.UI.AnimationStopState.complete);
        }
        this._fadingIn$2 = true;
        this.play();
    },
    
    fadeOut: function ScriptFX_UI_FadeEffect$fadeOut() {
        if (this.get_isPlaying()) {
            this.stop(ScriptFX.UI.AnimationStopState.complete);
        }
        this._fadingIn$2 = false;
        this.play();
    },
    
    performCleanup: function ScriptFX_UI_FadeEffect$performCleanup() {
        ScriptFX.UI.FadeEffect.callBase(this, 'performCleanup');
        if (!this._fadingIn$2) {
            this._setOpacity$2(0);
            this.get_domElement().style.display = 'none';
        }
    },
    
    performSetup: function ScriptFX_UI_FadeEffect$performSetup() {
        ScriptFX.UI.FadeEffect.callBase(this, 'performSetup');
        if (this._fadingIn$2) {
            this._setOpacity$2(0);
            this.get_domElement().style.display = '';
        }
    },
    
    performTweening: function ScriptFX_UI_FadeEffect$performTweening(frame) {
        if (this._fadingIn$2) {
            this._setOpacity$2(this._opacity$2 * frame);
        }
        else {
            this._setOpacity$2(this._opacity$2 * (1 - frame));
        }
    },
    
    _setOpacity$2: function ScriptFX_UI_FadeEffect$_setOpacity$2(opacity) {
        if (ScriptFX.Application.current.get_isIE()) {
            this.get_domElement().style.filter = 'alpha(opacity=' + (opacity * 100) + ')';
        }
        else {
            this.get_domElement().style.opacity = opacity.toString();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI._genericControl

ScriptFX.UI._genericControl = function ScriptFX_UI__genericControl(domElement) {
    ScriptFX.UI._genericControl.constructBase(this, [ domElement ]);
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.OverlayBehavior

ScriptFX.UI.OverlayBehavior = function ScriptFX_UI_OverlayBehavior(domElement, options) {
    ScriptFX.UI.OverlayBehavior.constructBase(this, [ domElement, options.id ]);
    this._overlayElement$1 = document.createElement('div');
    this._overlayElement$1.className = options.cssClass;
    var overlayStyle = this._overlayElement$1.style;
    overlayStyle.display = 'none';
    overlayStyle.top = '0px';
    overlayStyle.left = '0px';
    overlayStyle.width = '100%';
    if (ScriptFX.Application.current.get_isIE() && (ScriptFX.Application.current.get_host().get_majorVersion() < 7)) {
        overlayStyle.position = 'absolute';
    }
    else {
        this._fixedOverlayElement$1 = true;
        overlayStyle.position = 'fixed';
        overlayStyle.height = '100%';
    }
    document.body.appendChild(this._overlayElement$1);
    if (options.fadeInOutInterval) {
        this._fade$1 = new ScriptFX.UI.FadeEffect(this._overlayElement$1, options.fadeInOutInterval, options.opacity);
        this._fade$1.set_easingFunction(Delegate.create(null, ScriptFX.UI.TimedAnimation.easeInOut));
        this._fade$1.add_stopped(Delegate.create(this, this._onAnimationStopped$1));
    }
}
ScriptFX.UI.OverlayBehavior.prototype = {
    _overlayElement$1: null,
    _fixedOverlayElement$1: false,
    _fade$1: null,
    _resizeHandler$1: null,
    _visible$1: false,
    
    get_isVisible: function ScriptFX_UI_OverlayBehavior$get_isVisible() {
        return this._visible$1;
    },
    
    add_visibilityChanged: function ScriptFX_UI_OverlayBehavior$add_visibilityChanged(value) {
        this.get_events().addHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1, value);
    },
    remove_visibilityChanged: function ScriptFX_UI_OverlayBehavior$remove_visibilityChanged(value) {
        this.get_events().removeHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1, value);
    },
    
    dispose: function ScriptFX_UI_OverlayBehavior$dispose() {
        if (this._fade$1) {
            this._fade$1.dispose();
            this._fade$1 = null;
        }
        if (this._resizeHandler$1) {
            window.detachEvent('onresize', this._resizeHandler$1);
            this._resizeHandler$1 = null;
        }
        ScriptFX.UI.OverlayBehavior.callBase(this, 'dispose');
    },
    
    hide: function ScriptFX_UI_OverlayBehavior$hide() {
        if ((!this._visible$1) || this._fade$1.get_isPlaying()) {
            return;
        }
        if (this._resizeHandler$1) {
            window.detachEvent('onresize', this._resizeHandler$1);
            this._resizeHandler$1 = null;
        }
        if (this._fade$1) {
            this._fade$1.fadeOut();
        }
        else {
            this._overlayElement$1.style.display = 'none';
            this._visible$1 = false;
            var handler = this.get_events().getHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1);
            if (handler) {
                handler.invoke(this, EventArgs.Empty);
            }
        }
    },
    
    _onAnimationStopped$1: function ScriptFX_UI_OverlayBehavior$_onAnimationStopped$1(sender, e) {
        this._visible$1 = this._fade$1.get_isFadingIn();
        var handler = this.get_events().getHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1);
        if (handler) {
            handler.invoke(this, EventArgs.Empty);
        }
    },
    
    _onWindowResize$1: function ScriptFX_UI_OverlayBehavior$_onWindowResize$1() {
        this._overlayElement$1.style.height = document.documentElement.offsetHeight + 'px';
    },
    
    show: function ScriptFX_UI_OverlayBehavior$show() {
        if (this._visible$1 || this._fade$1.get_isPlaying()) {
            return;
        }
        if (!this._fixedOverlayElement$1) {
            this._overlayElement$1.style.height = document.documentElement.offsetHeight + 'px';
            this._resizeHandler$1 = Delegate.create(this, this._onWindowResize$1);
            window.attachEvent('onresize', this._resizeHandler$1);
        }
        if (this._fade$1) {
            this._fade$1.fadeIn();
        }
        else {
            this._overlayElement$1.style.display = '';
            this._visible$1 = true;
            var handler = this.get_events().getHandler(ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1);
            if (handler) {
                handler.invoke(this, EventArgs.Empty);
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.PopupBehavior

ScriptFX.UI.PopupBehavior = function ScriptFX_UI_PopupBehavior(domElement, options) {
    ScriptFX.UI.PopupBehavior.constructBase(this, [ domElement, options.id ]);
    this._options$1 = options;
    domElement.style.position = 'absolute';
    domElement.style.display = 'none';
}
ScriptFX.UI.PopupBehavior.prototype = {
    _options$1: null,
    _iframe$1: null,
    
    dispose: function ScriptFX_UI_PopupBehavior$dispose() {
        if (this.get_domElement()) {
            this.hide();
        }
        ScriptFX.UI.PopupBehavior.callBase(this, 'dispose');
    },
    
    hide: function ScriptFX_UI_PopupBehavior$hide() {
        this.get_domElement().style.display = 'none';
        if (this._iframe$1) {
            this._iframe$1.parentNode.removeChild(this._iframe$1);
            this._iframe$1 = null;
        }
    },
    
    show: function ScriptFX_UI_PopupBehavior$show() {
        var parentElement = this.get_domElement().offsetParent;
        if (!parentElement) {
            parentElement = document.documentElement;
        }
        this.get_domElement().style.display = 'block';
        var x = 0;
        var y = 0;
        var xOffsetDirection = 1;
        var yOffsetDirection = 1;
        var alignment = false;
        var parentBounds = ScriptFX.UI.Element.getBounds(parentElement);
        var elementBounds = ScriptFX.UI.Element.getBounds(this.get_domElement());
        var referenceBounds = ScriptFX.UI.Element.getBounds(this._options$1.referenceElement);
        var xDelta = referenceBounds.left - parentBounds.left;
        var yDelta = referenceBounds.top - parentBounds.top;
        switch (this._options$1.mode) {
            case ScriptFX.UI.PopupMode.center:
                x = Math.round(referenceBounds.width / 2 - elementBounds.width / 2);
                y = Math.round(referenceBounds.height / 2 - elementBounds.height / 2);
                break;
            case ScriptFX.UI.PopupMode.anchorTopLeft:
                x = 0;
                y = -elementBounds.height;
                break;
            case ScriptFX.UI.PopupMode.anchorTopRight:
                x = referenceBounds.width - elementBounds.width;
                y = -elementBounds.height;
                break;
            case ScriptFX.UI.PopupMode.anchorBottomRight:
                x = referenceBounds.width - elementBounds.width;
                y = referenceBounds.height;
                break;
            case ScriptFX.UI.PopupMode.anchorBottomLeft:
                x = 0;
                y = referenceBounds.height;
                break;
            case ScriptFX.UI.PopupMode.alignTopLeft:
                x = referenceBounds.left;
                y = referenceBounds.top;
                alignment = true;
                break;
            case ScriptFX.UI.PopupMode.alignTopRight:
                x = referenceBounds.left + referenceBounds.width - elementBounds.width;
                y = referenceBounds.top;
                xOffsetDirection = -1;
                alignment = true;
                break;
            case ScriptFX.UI.PopupMode.alignBottomRight:
                x = referenceBounds.left + referenceBounds.width - elementBounds.width;
                y = referenceBounds.top + referenceBounds.height - elementBounds.height;
                xOffsetDirection = -1;
                yOffsetDirection = -1;
                alignment = true;
                break;
            case ScriptFX.UI.PopupMode.alignBottomLeft:
                x = referenceBounds.left;
                y = referenceBounds.top + referenceBounds.height - elementBounds.height;
                yOffsetDirection = -1;
                alignment = true;
                break;
        }
        if (!alignment) {
            x += xDelta + this._options$1.xOffset;
            y += yDelta + this._options$1.yOffset;
        }
        else {
            x += xDelta + this._options$1.xOffset * xOffsetDirection;
            y += yDelta + this._options$1.yOffset * yOffsetDirection;
        }
        var docWidth = document.body.clientWidth;
        if (x + elementBounds.width > docWidth - 2) {
            x -= (x + elementBounds.width - docWidth + 2);
        }
        if (x < 0) {
            x = 2;
        }
        if (y < 0) {
            y = 2;
        }
        ScriptFX.UI.Element.setLocation(this.get_domElement(), ScriptFX.UI.$create_Location(x, y));
        var host = ScriptFX.Application.current.get_host();
        if ((host.get_name() === ScriptFX.HostName.IE) && (host.get_majorVersion() < 7)) {
            this._iframe$1 = document.createElement('IFRAME');
            this._iframe$1.src = 'javascript:false;';
            this._iframe$1.scrolling = 'no';
            this._iframe$1.style.position = 'absolute';
            this._iframe$1.style.display = 'block';
            this._iframe$1.style.border = 'none';
            this._iframe$1.style.filter = 'progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0)';
            this._iframe$1.style.left = x + 'px';
            this._iframe$1.style.top = y + 'px';
            this._iframe$1.style.width = elementBounds.width + 'px';
            this._iframe$1.style.height = elementBounds.height + 'px';
            this._iframe$1.style.zIndex = 1;
            this.get_domElement().parentNode.insertBefore(this._iframe$1, this.get_domElement());
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.TimedAnimation

ScriptFX.UI.TimedAnimation = function ScriptFX_UI_TimedAnimation(domElement, duration) {
    ScriptFX.UI.TimedAnimation.constructBase(this, [ domElement ]);
    Debug.assert(duration > 0);
    this._duration$1 = duration;
}
ScriptFX.UI.TimedAnimation.easeIn = function ScriptFX_UI_TimedAnimation$easeIn(t) {
    return t * t;
}
ScriptFX.UI.TimedAnimation.easeInOut = function ScriptFX_UI_TimedAnimation$easeInOut(t) {
    t = t * 2;
    if (t < 1) {
        return t * t / 2;
    }
    return -((--t) * (t - 2) - 1) / 2;
}
ScriptFX.UI.TimedAnimation.easeOut = function ScriptFX_UI_TimedAnimation$easeOut(t) {
    return -t * (t - 2);
}
ScriptFX.UI.TimedAnimation.prototype = {
    _duration$1: 0,
    _easingFunction$1: null,
    _startTimeStamp$1: 0,
    
    get_duration: function ScriptFX_UI_TimedAnimation$get_duration() {
        return this._duration$1;
    },
    set_duration: function ScriptFX_UI_TimedAnimation$set_duration(value) {
        Debug.assert(!this.get_isPlaying());
        Debug.assert(this._duration$1 >= 0);
        this._duration$1 = value;
        return value;
    },
    
    get_easingFunction: function ScriptFX_UI_TimedAnimation$get_easingFunction() {
        return this._easingFunction$1;
    },
    set_easingFunction: function ScriptFX_UI_TimedAnimation$set_easingFunction(value) {
        Debug.assert(!this.get_isPlaying());
        this._easingFunction$1 = value;
        return value;
    },
    
    playCore: function ScriptFX_UI_TimedAnimation$playCore() {
        this._startTimeStamp$1 = (new Date()).getTime();
        this.progressCore(false, this._startTimeStamp$1);
    },
    
    progressCore: function ScriptFX_UI_TimedAnimation$progressCore(startRepetition, timeStamp) {
        var frame = 0;
        var completed = false;
        if (!startRepetition) {
            frame = (timeStamp - this._startTimeStamp$1) / this._duration$1;
            if (!this.get_isReversed()) {
                completed = (frame >= 1);
                frame = Math.min(1, frame);
            }
            else {
                frame = 1 - frame;
                completed = (frame <= 0);
                frame = Math.max(0, frame);
            }
            if ((!completed) && (this._easingFunction$1)) {
                frame = this._easingFunction$1.invoke(frame);
            }
        }
        else {
            this._startTimeStamp$1 = timeStamp;
            if (this.get_isReversed()) {
                frame = 1;
            }
        }
        this.performTweening(frame);
        return completed;
    },
    
    stopCore: function ScriptFX_UI_TimedAnimation$stopCore(completed, stopState) {
        if (!completed) {
            if (stopState === ScriptFX.UI.AnimationStopState.complete) {
                this.performTweening(1);
            }
            else if (stopState === ScriptFX.UI.AnimationStopState.revert) {
                this.performTweening(0);
            }
        }
    }
}


ScriptFX.Application.createClass('ScriptFX.Application', null, IServiceProvider, IServiceContainer, ScriptFX.IEventManager);
ScriptFX.CancelEventArgs.createClass('ScriptFX.CancelEventArgs', EventArgs);
ScriptFX.CollectionChangedEventArgs.createClass('ScriptFX.CollectionChangedEventArgs', EventArgs);
ScriptFX.ApplicationUnloadingEventArgs.createClass('ScriptFX.ApplicationUnloadingEventArgs', EventArgs);
ScriptFX.HistoryManager.createClass('ScriptFX.HistoryManager', null, IDisposable);
ScriptFX.HistoryEventArgs.createClass('ScriptFX.HistoryEventArgs', EventArgs);
ScriptFX.HostInfo.createClass('ScriptFX.HostInfo');
ScriptFX.EventList.createClass('ScriptFX.EventList');
ScriptFX.JSON.createClass('ScriptFX.JSON');
ScriptFX.PropertyChangedEventArgs.createClass('ScriptFX.PropertyChangedEventArgs', EventArgs);
ScriptFX.ObservableCollection.createClass('ScriptFX.ObservableCollection', null, IDisposable, IArray, IEnumerable, ScriptFX.INotifyCollectionChanged);
ScriptFX.Net.HTTPRequest.createClass('ScriptFX.Net.HTTPRequest', null, IDisposable);
ScriptFX.Net.HTTPRequestManager.createClass('ScriptFX.Net.HTTPRequestManager');
ScriptFX.Net.HTTPTransport.createClass('ScriptFX.Net.HTTPTransport', null, IDisposable);
ScriptFX.Net.PostHTTPRequestEventArgs.createClass('ScriptFX.Net.PostHTTPRequestEventArgs', EventArgs);
ScriptFX.Net.PreHTTPRequestEventArgs.createClass('ScriptFX.Net.PreHTTPRequestEventArgs', EventArgs);
ScriptFX.Net._xmlhttpResponse.createClass('ScriptFX.Net._xmlhttpResponse', null, ScriptFX.Net.IHTTPResponse);
ScriptFX.Net._xmlhttpTransport.createClass('ScriptFX.Net._xmlhttpTransport', ScriptFX.Net.HTTPTransport);
ScriptFX.UI.Animation.createClass('ScriptFX.UI.Animation', null, IDisposable);
ScriptFX.UI.AnimationManager.createClass('ScriptFX.UI.AnimationManager');
ScriptFX.UI.AnimationSequence.createClass('ScriptFX.UI.AnimationSequence', ScriptFX.UI.Animation);
ScriptFX.UI.Behavior.createClass('ScriptFX.UI.Behavior', null, IDisposable, ScriptFX.ISupportInitialize, ScriptFX.INotifyPropertyChanged);
ScriptFX.UI.Color.createClass('ScriptFX.UI.Color');
ScriptFX.UI.Control.createClass('ScriptFX.UI.Control', ScriptFX.UI.Behavior, ScriptFX.INotifyDisposing);
ScriptFX.UI.DOMEventList.createClass('ScriptFX.UI.DOMEventList', null, IDisposable);
ScriptFX.UI.DragDropEventArgs.createClass('ScriptFX.UI.DragDropEventArgs', EventArgs);
ScriptFX.UI.DragDropManager.createClass('ScriptFX.UI.DragDropManager');
ScriptFX.UI._dragDropTracker.createClass('ScriptFX.UI._dragDropTracker', null, ScriptFX.UI.IDragSource);
ScriptFX.UI.Element.createClass('ScriptFX.UI.Element');
ScriptFX.UI.TimedAnimation.createClass('ScriptFX.UI.TimedAnimation', ScriptFX.UI.Animation);
ScriptFX.UI.FadeEffect.createClass('ScriptFX.UI.FadeEffect', ScriptFX.UI.TimedAnimation);
ScriptFX.UI._genericControl.createClass('ScriptFX.UI._genericControl', ScriptFX.UI.Control);
ScriptFX.UI.OverlayBehavior.createClass('ScriptFX.UI.OverlayBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.PopupBehavior.createClass('ScriptFX.UI.PopupBehavior', ScriptFX.UI.Behavior);
ScriptFX.Application.current = new ScriptFX.Application();
ScriptFX.JSON._dateRegex = null;
ScriptFX.Net.HTTPRequestManager.__requestInvoking = null;
ScriptFX.Net.HTTPRequestManager.__requestInvoked = null;
ScriptFX.Net.HTTPRequestManager._timeoutInterval = 0;
ScriptFX.Net.HTTPRequestManager._activeRequests = [];
ScriptFX.Net.HTTPRequestManager._appIdleHandler = null;
ScriptFX.UI.AnimationManager._fps = 100;
ScriptFX.UI.AnimationManager._activeAnimations = null;
ScriptFX.UI.AnimationManager._timerCookie = 0;
ScriptFX.UI.DragDropManager._dragDropImplementation = null;
ScriptFX.UI.DragDropManager._dropTargets = [];
ScriptFX.UI.DragDropManager._dragStartingHandler = null;
ScriptFX.UI.DragDropManager._dragEndingHandler = null;
ScriptFX.UI.DragDropManager._currentDataObject = null;
ScriptFX.UI.OverlayBehavior._visibilityChangedEventKey$1 = 'visibilityChanged';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
// Script# Framework
// Copyright (c) 2006, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX.Reflection');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.MemberInfoType

ScriptFX.Reflection.MemberInfoType = function() { };
ScriptFX.Reflection.MemberInfoType.prototype = {
    Field: 0, 
    Method: 1, 
    Property: 2, 
    Event: 3
}
ScriptFX.Reflection.MemberInfoType.createEnum('ScriptFX.Reflection.MemberInfoType', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.TypeInfoType

ScriptFX.Reflection.TypeInfoType = function() { };
ScriptFX.Reflection.TypeInfoType.prototype = {
    Class: 0, 
    Interface: 1, 
    Enumeration: 2, 
    FlagsEnumeration: 3
}
ScriptFX.Reflection.TypeInfoType.createEnum('ScriptFX.Reflection.TypeInfoType', false);


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.ParameterInfo

ScriptFX.Reflection.ParameterInfo = function ScriptFX_Reflection_ParameterInfo(name) {
    this._name = name;
}
ScriptFX.Reflection.ParameterInfo.prototype = {
    _name: null,
    
    get_name: function ScriptFX_Reflection_ParameterInfo$get_name() {
        return this._name;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.FieldInfo

ScriptFX.Reflection.FieldInfo = function ScriptFX_Reflection_FieldInfo(name, fieldType, isStatic) {
    ScriptFX.Reflection.FieldInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Field, name, fieldType, isStatic ]);
}
ScriptFX.Reflection.FieldInfo.prototype = {
    _value$1: null,
    
    get_value: function ScriptFX_Reflection_FieldInfo$get_value() {
        return this._value$1;
    },
    
    _initialize: function ScriptFX_Reflection_FieldInfo$_initialize(value) {
        this._value$1 = value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.Reflector

ScriptFX.Reflection.Reflector = function ScriptFX_Reflection_Reflector() {
}
ScriptFX.Reflection.Reflector.getGlobalTypes = function ScriptFX_Reflection_Reflector$getGlobalTypes() {
    if (!ScriptFX.Reflection.Reflector._globalTypes) {
        var globalTypes = [];
        var classTypes = [ Object, Boolean, Number, String, Date, Array, Function, RegExp, StringBuilder, EventArgs ];
        var interfaceTypes = [ IDisposable, IEnumerable, IEnumerator, IArray ];
        var $enum1 = classTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var type = $enum1.get_current();
            var typeInfo = new ScriptFX.Reflection.TypeInfo(null, ScriptFX.Reflection.TypeInfoType.Class, type.get_name());
            typeInfo._initialize(type);
            globalTypes.add(typeInfo);
        }
        var $enum2 = interfaceTypes.getEnumerator();
        while ($enum2.moveNext()) {
            var type = $enum2.get_current();
            var typeInfo = new ScriptFX.Reflection.TypeInfo(null, ScriptFX.Reflection.TypeInfoType.Interface, type.get_name());
            typeInfo._initialize(type);
            globalTypes.add(typeInfo);
        }
        ScriptFX.Reflection.Reflector._globalTypes = globalTypes;
    }
    return ScriptFX.Reflection.Reflector._globalTypes;
}
ScriptFX.Reflection.Reflector.getNamespaces = function ScriptFX_Reflection_Reflector$getNamespaces() {
    if (!ScriptFX.Reflection.Reflector._namespaces) {
        var namespaceTable = window.__namespaces;
        ScriptFX.Reflection.Reflector._namespaces = [];
        var $dict1 = namespaceTable;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            ScriptFX.Reflection.Reflector._namespaces.add(new ScriptFX.Reflection.NamespaceInfo(entry.key, entry.value));
        }
    }
    return ScriptFX.Reflection.Reflector._namespaces;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.PropertyInfo

ScriptFX.Reflection.PropertyInfo = function ScriptFX_Reflection_PropertyInfo(name, propertyType, isStatic) {
    ScriptFX.Reflection.PropertyInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Property, name, propertyType, isStatic ]);
}
ScriptFX.Reflection.PropertyInfo.prototype = {
    _getAccessor$1: null,
    _setAccessor$1: null,
    
    get_getAccessor: function ScriptFX_Reflection_PropertyInfo$get_getAccessor() {
        return this._getAccessor$1;
    },
    
    get_isReadOnly: function ScriptFX_Reflection_PropertyInfo$get_isReadOnly() {
        return (!this._setAccessor$1);
    },
    
    get_setAccessor: function ScriptFX_Reflection_PropertyInfo$get_setAccessor() {
        return this._setAccessor$1;
    },
    
    _initialize: function ScriptFX_Reflection_PropertyInfo$_initialize(getAccessor, setAccessor) {
        this._getAccessor$1 = getAccessor;
        this._setAccessor$1 = setAccessor;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.EventInfo

ScriptFX.Reflection.EventInfo = function ScriptFX_Reflection_EventInfo(name, argsType, isStatic) {
    ScriptFX.Reflection.EventInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Event, name, argsType, isStatic ]);
}
ScriptFX.Reflection.EventInfo.prototype = {
    _addAccessor$1: null,
    _removeAccessor$1: null,
    
    get_addAccessor: function ScriptFX_Reflection_EventInfo$get_addAccessor() {
        return this._addAccessor$1;
    },
    
    get_removeAccessor: function ScriptFX_Reflection_EventInfo$get_removeAccessor() {
        return this._removeAccessor$1;
    },
    
    _initialialize: function ScriptFX_Reflection_EventInfo$_initialialize(addAccessor, removeAccessor) {
        this._addAccessor$1 = addAccessor;
        this._removeAccessor$1 = removeAccessor;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.MethodInfo

ScriptFX.Reflection.MethodInfo = function ScriptFX_Reflection_MethodInfo(name, returnType, isStatic) {
    ScriptFX.Reflection.MethodInfo.constructBase(this, [ ScriptFX.Reflection.MemberInfoType.Method, name, returnType, isStatic ]);
}
ScriptFX.Reflection.MethodInfo.prototype = {
    _isConstructor$1: false,
    _method$1: null,
    _parameters$1: null,
    
    get_constructor: function ScriptFX_Reflection_MethodInfo$get_constructor() {
        return this._isConstructor$1;
    },
    
    get_method: function ScriptFX_Reflection_MethodInfo$get_method() {
        return this._method$1;
    },
    
    get_parameters: function ScriptFX_Reflection_MethodInfo$get_parameters() {
        return this._parameters$1;
    },
    
    _initialize: function ScriptFX_Reflection_MethodInfo$_initialize(isConstructor, method) {
        this._isConstructor$1 = isConstructor;
        this._method$1 = method;
        var sourceCode = method.toString();
        var indexOpenParen = sourceCode.indexOf('(');
        var indexCloseParen = sourceCode.indexOf(')');
        var signature = sourceCode.substring(indexOpenParen + 1, indexCloseParen).trim();
        var parameters = [];
        if (signature.length) {
            var paramNames = signature.split(',');
            for (var i = 0; i < paramNames.length; i++) {
                parameters[i] = new ScriptFX.Reflection.ParameterInfo(paramNames[i].trim());
            }
        }
        this._parameters$1 = parameters;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.MemberInfo

ScriptFX.Reflection.MemberInfo = function ScriptFX_Reflection_MemberInfo(memberType, name, type, isStatic) {
    this._memberType = memberType;
    this._name = name;
    this._type = type;
    this._isStatic = isStatic;
}
ScriptFX.Reflection.MemberInfo.prototype = {
    _memberType: 0,
    _name: null,
    _type: null,
    _isStatic: false,
    
    get_associatedType: function ScriptFX_Reflection_MemberInfo$get_associatedType() {
        return this._type;
    },
    
    get_isPublic: function ScriptFX_Reflection_MemberInfo$get_isPublic() {
        return (!this._name.startsWith('_')) && (!this._name.startsWith('$'));
    },
    
    get_isStatic: function ScriptFX_Reflection_MemberInfo$get_isStatic() {
        return this._isStatic;
    },
    
    get_memberType: function ScriptFX_Reflection_MemberInfo$get_memberType() {
        return this._memberType;
    },
    
    get_name: function ScriptFX_Reflection_MemberInfo$get_name() {
        return this._name;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.NamespaceInfo

ScriptFX.Reflection.NamespaceInfo = function ScriptFX_Reflection_NamespaceInfo(name, typeTable) {
    this._name = name;
    this._typeTable = typeTable;
}
ScriptFX.Reflection.NamespaceInfo.prototype = {
    _name: null,
    _typeTable: null,
    _types: null,
    
    get_name: function ScriptFX_Reflection_NamespaceInfo$get_name() {
        return this._name;
    },
    
    getTypes: function ScriptFX_Reflection_NamespaceInfo$getTypes() {
        if (!this._types) {
            this._types = [];
            var $dict1 = this._typeTable;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                var typeInfo = null;
                var type = entry.value;
                if (Type.isClass(type)) {
                    typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.Class, entry.key);
                }
                else if (Type.isInterface(type)) {
                    typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.Interface, entry.key);
                }
                else if (Type.isEnum(type)) {
                    if (Type.isFlagsEnum(type)) {
                        typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.FlagsEnumeration, entry.key);
                    }
                    else {
                        typeInfo = new ScriptFX.Reflection.TypeInfo(this, ScriptFX.Reflection.TypeInfoType.Enumeration, entry.key);
                    }
                }
                if (typeInfo) {
                    typeInfo._initialize(type);
                    this._types.add(typeInfo);
                }
            }
        }
        return this._types;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Reflection.TypeInfo

ScriptFX.Reflection.TypeInfo = function ScriptFX_Reflection_TypeInfo(parent, typeType, name) {
    this._parent = parent;
    this._typeType = typeType;
    this._name = name;
}
ScriptFX.Reflection.TypeInfo.prototype = {
    _parent: null,
    _typeType: 0,
    _type: null,
    _name: null,
    
    get_baseType: function ScriptFX_Reflection_TypeInfo$get_baseType() {
        return null;
    },
    
    get_fullName: function ScriptFX_Reflection_TypeInfo$get_fullName() {
        if (this._parent) {
            return this._parent.get_name() + '.' + this.get_name();
        }
        return this.get_name();
    },
    
    get_interfaces: function ScriptFX_Reflection_TypeInfo$get_interfaces() {
        return null;
    },
    
    get_isGlobal: function ScriptFX_Reflection_TypeInfo$get_isGlobal() {
        return (!this._parent);
    },
    
    get_isPublic: function ScriptFX_Reflection_TypeInfo$get_isPublic() {
        return (!this._name.startsWith('_')) && (!this._name.startsWith('$'));
    },
    
    get_name: function ScriptFX_Reflection_TypeInfo$get_name() {
        return this._name;
    },
    
    get_typeType: function ScriptFX_Reflection_TypeInfo$get_typeType() {
        return this._typeType;
    },
    
    _initialize: function ScriptFX_Reflection_TypeInfo$_initialize(type) {
        this._type = type;
    }
}


ScriptFX.Reflection.ParameterInfo.createClass('ScriptFX.Reflection.ParameterInfo');
ScriptFX.Reflection.MemberInfo.createClass('ScriptFX.Reflection.MemberInfo');
ScriptFX.Reflection.FieldInfo.createClass('ScriptFX.Reflection.FieldInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.Reflector.createClass('ScriptFX.Reflection.Reflector');
ScriptFX.Reflection.PropertyInfo.createClass('ScriptFX.Reflection.PropertyInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.EventInfo.createClass('ScriptFX.Reflection.EventInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.MethodInfo.createClass('ScriptFX.Reflection.MethodInfo', ScriptFX.Reflection.MemberInfo);
ScriptFX.Reflection.NamespaceInfo.createClass('ScriptFX.Reflection.NamespaceInfo');
ScriptFX.Reflection.TypeInfo.createClass('ScriptFX.Reflection.TypeInfo');
ScriptFX.Reflection.Reflector._globalTypes = null;
ScriptFX.Reflection.Reflector._namespaces = null;

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
// Script# Framework
// Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX.UI');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteOptions

ScriptFX.UI.$create_AutoCompleteOptions = function ScriptFX_UI_AutoCompleteOptions(service) {
    var $o = { };
    Debug.assert(!String.isNullOrEmpty(service), 'service parameter must not be empty.');
    $o.service = service;
    $o.id = null;
    $o.itemCount = 10;
    $o.itemLookupDelay = 500;
    $o.minimumPrefixLength = 3;
    $o.cssClass = 'autoComplete';
    $o.itemCSSClass = 'autoCompleteItem';
    $o.selectedItemCSSClass = 'autoCompleteSelectedItem';
    $o.xOffset = 0;
    $o.yOffset = 0;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.EnterKeyOptions

ScriptFX.UI.$create_EnterKeyOptions = function ScriptFX_UI_EnterKeyOptions(clickTarget) {
    var $o = { };
    Debug.assert(clickTarget);
    $o.clickTarget = clickTarget;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.WatermarkOptions

ScriptFX.UI.$create_WatermarkOptions = function ScriptFX_UI_WatermarkOptions(watermarkText, watermarkCssClass) {
    var $o = { };
    $o.watermarkText = watermarkText;
    $o.watermarkCssClass = watermarkCssClass;
    return $o;
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteBehavior

ScriptFX.UI.AutoCompleteBehavior = function ScriptFX_UI_AutoCompleteBehavior(domElement, options) {
    ScriptFX.UI.AutoCompleteBehavior.constructBase(this, [ domElement, options.id ]);
    this._options$1 = options;
    this._selectedItemIndex$1 = -1;
    domElement.autocomplete = 'off';
    var events = this.get_domEvents();
    events.attach('onfocus', Delegate.create(this, this._onTextBoxFocus$1));
    events.attach('onblur', Delegate.create(this, this._onTextBoxBlur$1));
    events.attach('onkeydown', Delegate.create(this, this._onTextBoxKeyDown$1));
}
ScriptFX.UI.AutoCompleteBehavior.prototype = {
    _options$1: null,
    _arguments$1: null,
    _dropDown$1: null,
    _dropDownPopup$1: null,
    _dropDownEvents$1: null,
    _dropDownVisible$1: false,
    _selectedItemIndex$1: 0,
    _itemCache$1: null,
    _timerID$1: 0,
    _currentPrefix$1: null,
    _itemRequest$1: null,
    
    get_arguments: function ScriptFX_UI_AutoCompleteBehavior$get_arguments() {
        if (!this._arguments$1) {
            this._arguments$1 = {};
        }
        return this._arguments$1;
    },
    
    add_itemDisplay: function ScriptFX_UI_AutoCompleteBehavior$add_itemDisplay(value) {
        this.get_events().addHandler('itemDisplay', value);
    },
    remove_itemDisplay: function ScriptFX_UI_AutoCompleteBehavior$remove_itemDisplay(value) {
        this.get_events().removeHandler('itemDisplay', value);
    },
    
    add_itemSelected: function ScriptFX_UI_AutoCompleteBehavior$add_itemSelected(value) {
        this.get_events().addHandler('itemSelected', value);
    },
    remove_itemSelected: function ScriptFX_UI_AutoCompleteBehavior$remove_itemSelected(value) {
        this.get_events().removeHandler('itemSelected', value);
    },
    
    add_requestingItems: function ScriptFX_UI_AutoCompleteBehavior$add_requestingItems(value) {
        this.get_events().addHandler('requestingItems', value);
    },
    remove_requestingItems: function ScriptFX_UI_AutoCompleteBehavior$remove_requestingItems(value) {
        this.get_events().removeHandler('requestingItems', value);
    },
    
    _abortRequest$1: function ScriptFX_UI_AutoCompleteBehavior$_abortRequest$1() {
        if (this._itemRequest$1) {
            this._itemRequest$1.abort();
            this._itemRequest$1 = null;
        }
    },
    
    clearCache: function ScriptFX_UI_AutoCompleteBehavior$clearCache() {
        this._itemCache$1 = null;
    },
    
    _createDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_createDropDown$1() {
        Debug.assert(!this._dropDown$1);
        this._dropDown$1 = document.createElement('DIV');
        if (this._options$1.cssClass) {
            this._dropDown$1.className = this._options$1.cssClass;
        }
        this._dropDown$1.unselectable = 'unselectable';
        document.body.appendChild(this._dropDown$1);
        this._dropDownEvents$1 = new ScriptFX.UI.DOMEventList(this._dropDown$1);
        this._dropDownEvents$1.attach('onmousedown', Delegate.create(this, this._onDropDownMouseDown$1));
        this._dropDownEvents$1.attach('onmouseup', Delegate.create(this, this._onDropDownMouseUp$1));
        this._dropDownEvents$1.attach('onmouseover', Delegate.create(this, this._onDropDownMouseOver$1));
        var options = ScriptFX.UI.$create_PopupOptions(this.get_domElement(), ScriptFX.UI.PopupMode.anchorBottomLeft);
        options.xOffset = this._options$1.xOffset;
        options.yOffset = -1 + this._options$1.yOffset;
        this._dropDownPopup$1 = new ScriptFX.UI.PopupBehavior(this._dropDown$1, options);
    },
    
    dispose: function ScriptFX_UI_AutoCompleteBehavior$dispose() {
        this._stopTimer$1();
        this._abortRequest$1();
        if (this._dropDown$1) {
            this._dropDownEvents$1.dispose();
            this._dropDownEvents$1 = null;
            this._dropDownPopup$1.dispose();
            this._dropDownPopup$1 = null;
            document.body.removeChild(this._dropDown$1);
            this._dropDown$1 = null;
            this._dropDownVisible$1 = false;
        }
        ScriptFX.UI.AutoCompleteBehavior.callBase(this, 'dispose');
    },
    
    _getDropDownItem$1: function ScriptFX_UI_AutoCompleteBehavior$_getDropDownItem$1(element) {
        while ((element) && (element !== this._dropDown$1)) {
            if (!isUndefined(element.__item)) {
                return element;
            }
            element = element.parentNode;
        }
        return null;
    },
    
    _hideDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_hideDropDown$1() {
        if (this._dropDownVisible$1) {
            this._dropDownVisible$1 = false;
            this._dropDownPopup$1.hide();
            this._selectedItemIndex$1 = -1;
        }
    },
    
    _highlightDropDownItem$1: function ScriptFX_UI_AutoCompleteBehavior$_highlightDropDownItem$1(itemElement) {
        if (this._options$1.selectedItemCSSClass) {
            ScriptFX.UI.Element.addCSSClass(itemElement, this._options$1.selectedItemCSSClass);
        }
    },
    
    _onDropDownMouseDown$1: function ScriptFX_UI_AutoCompleteBehavior$_onDropDownMouseDown$1() {
        var element = this._getDropDownItem$1(window.event.srcElement);
        if (element) {
            var item = element.__item;
            var index = element.__index;
            this._updateTextBox$1(item, index);
        }
    },
    
    _onDropDownMouseUp$1: function ScriptFX_UI_AutoCompleteBehavior$_onDropDownMouseUp$1() {
        this.get_domElement().focus();
    },
    
    _onDropDownMouseOver$1: function ScriptFX_UI_AutoCompleteBehavior$_onDropDownMouseOver$1() {
        var element = this._getDropDownItem$1(window.event.srcElement);
        if (this._selectedItemIndex$1 !== -1) {
            this._unhighlightItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
            this._selectedItemIndex$1 = -1;
        }
        if (element) {
            var selectedItemIndex = element.__index;
            if (!isUndefined(this._selectedItemIndex$1)) {
                this._selectedItemIndex$1 = selectedItemIndex;
                this._highlightDropDownItem$1(element);
                return;
            }
        }
    },
    
    _onRequestComplete$1: function ScriptFX_UI_AutoCompleteBehavior$_onRequestComplete$1(request, context) {
        if ((request !== this._itemRequest$1) || (request.get_state() !== ScriptFX.Net.HTTPRequestState.completed) || (request.get_response().get_statusCode() !== ScriptFX.Net.HTTPStatusCode.OK)) {
            return;
        }
        var parameters = context;
        var prefixText = parameters['prefix'];
        var cacheKey = prefixText;
        if (this.get_events().getHandler('requestingItems')) {
            delete parameters.prefix;
            delete parameters.count;
            cacheKey += ScriptFX.JSON.serialize(parameters);
        }
        var items = request.get_response().getObject();
        this._updateDropDown$1(prefixText, items, cacheKey);
    },
    
    _onTextBoxBlur$1: function ScriptFX_UI_AutoCompleteBehavior$_onTextBoxBlur$1() {
        this._stopTimer$1();
        this._abortRequest$1();
        this._hideDropDown$1();
    },
    
    _onTextBoxFocus$1: function ScriptFX_UI_AutoCompleteBehavior$_onTextBoxFocus$1() {
        this._startTimer$1();
    },
    
    _onTextBoxKeyDown$1: function ScriptFX_UI_AutoCompleteBehavior$_onTextBoxKeyDown$1() {
        this._stopTimer$1();
        var e = window.event;
        if (this._dropDownVisible$1) {
            switch (e.keyCode) {
                case ScriptFX.UI.Key.escape:
                    this._hideDropDown$1();
                    e.returnValue = false;
                    break;
                case ScriptFX.UI.Key.up:
                    if (this._selectedItemIndex$1 > 0) {
                        this._unhighlightItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                        this._selectedItemIndex$1--;
                        this._highlightDropDownItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                    }
                    else if (this._selectedItemIndex$1 === -1) {
                        this._selectedItemIndex$1 = this._dropDown$1.childNodes.length - 1;
                        this._highlightDropDownItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                    }
                    e.returnValue = false;
                    break;
                case ScriptFX.UI.Key.down:
                    if (this._selectedItemIndex$1 < (this._dropDown$1.childNodes.length - 1)) {
                        if (this._selectedItemIndex$1 === -1) {
                            this._selectedItemIndex$1 = 0;
                        }
                        else {
                            this._unhighlightItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                            this._selectedItemIndex$1++;
                        }
                        this._highlightDropDownItem$1(this._dropDown$1.childNodes[this._selectedItemIndex$1]);
                    }
                    e.returnValue = false;
                    break;
                case ScriptFX.UI.Key.enter:
                    if (this._selectedItemIndex$1 !== -1) {
                        var item = this._dropDown$1.childNodes[this._selectedItemIndex$1].__item;
                        var index = this._dropDown$1.childNodes[this._selectedItemIndex$1].__index;
                        this._updateTextBox$1(item, index);
                    }
                    e.returnValue = false;
                    break;
            }
        }
        if (e.keyCode !== ScriptFX.UI.Key.tab) {
            this._startTimer$1();
        }
    },
    
    _onTimerTick$1: function ScriptFX_UI_AutoCompleteBehavior$_onTimerTick$1() {
        this._timerID$1 = 0;
        this._abortRequest$1();
        var text = (this.get_domElement()).value;
        if (text === this._currentPrefix$1) {
            return;
        }
        if (text.trim().length < this._options$1.minimumPrefixLength) {
            this._updateDropDown$1(null, null, null);
            return;
        }
        this._currentPrefix$1 = text;
        var requestHandler = this.get_events().getHandler('requestingItems');
        if (requestHandler) {
            var e = new ScriptFX.UI.AutoCompleteRequestEventArgs(text);
            requestHandler.invoke(this, e);
            var items = e.get__items();
            if (items) {
                this._updateDropDown$1(text, items, null);
                return;
            }
        }
        if (this._itemCache$1) {
            var cacheKey = text;
            if (this._arguments$1) {
                delete this._arguments$1.prefix;
                delete this._arguments$1.count;
                cacheKey += ScriptFX.JSON.serialize(this._arguments$1);
            }
            var items = this._itemCache$1[cacheKey];
            if (items) {
                this._updateDropDown$1(text, items, null);
                return;
            }
        }
        var parameters;
        if (this._arguments$1) {
            parameters = this._arguments$1;
        }
        else {
            parameters = {};
        }
        parameters['prefix'] = text;
        parameters['count'] = this._options$1.itemCount;
        this._itemRequest$1 = ScriptFX.Net.HTTPRequest.createRequest(ScriptFX.Net.HTTPRequest.createURI(this._options$1.service, parameters), ScriptFX.Net.HTTPVerb.GET);
        this._itemRequest$1.invoke(Delegate.create(this, this._onRequestComplete$1), parameters);
    },
    
    _showDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_showDropDown$1() {
        if (!this._dropDownVisible$1) {
            this._dropDownVisible$1 = true;
            this._dropDown$1.style.width = (this.get_domElement().offsetWidth - 2) + 'px';
            this._dropDownPopup$1.show();
        }
    },
    
    _startTimer$1: function ScriptFX_UI_AutoCompleteBehavior$_startTimer$1() {
        if (!this._timerID$1) {
            this._timerID$1 = window.setTimeout(Delegate.create(this, this._onTimerTick$1), this._options$1.itemLookupDelay);
        }
    },
    
    _stopTimer$1: function ScriptFX_UI_AutoCompleteBehavior$_stopTimer$1() {
        if (this._timerID$1) {
            window.clearTimeout(this._timerID$1);
            this._timerID$1 = 0;
        }
    },
    
    _unhighlightItem$1: function ScriptFX_UI_AutoCompleteBehavior$_unhighlightItem$1(itemElement) {
        if (this._options$1.selectedItemCSSClass) {
            ScriptFX.UI.Element.removeCSSClass(itemElement, this._options$1.selectedItemCSSClass);
        }
    },
    
    _updateDropDown$1: function ScriptFX_UI_AutoCompleteBehavior$_updateDropDown$1(prefixText, items, cacheKey) {
        var itemCount = 0;
        if (items) {
            itemCount = items.length;
        }
        if ((cacheKey) && (itemCount)) {
            if (!this._itemCache$1) {
                this._itemCache$1 = {};
            }
            this._itemCache$1[cacheKey] = items;
        }
        if (!this._dropDown$1) {
            this._createDropDown$1();
        }
        this._dropDown$1.innerHTML = '';
        this._selectedItemIndex$1 = -1;
        if (itemCount) {
            for (var i = 0; i < itemCount; i++) {
                var itemElement = document.createElement('DIV');
                if (this._options$1.itemCSSClass) {
                    itemElement.className = this._options$1.itemCSSClass;
                }
                var item = items[i];
                var text = item;
                var displayHandler = this.get_events().getHandler('itemDisplay');
                if (displayHandler) {
                    var e = new ScriptFX.UI.AutoCompleteItemEventArgs(item, i);
                    displayHandler.invoke(this, e);
                    text = e.get_text();
                    if (!text) {
                        text = item;
                    }
                }
                itemElement.innerHTML = text;
                itemElement.__index = i;
                itemElement.__item = items[i];
                this._dropDown$1.appendChild(itemElement);
            }
            this._showDropDown$1();
        }
        else {
            this._hideDropDown$1();
        }
    },
    
    _updateTextBox$1: function ScriptFX_UI_AutoCompleteBehavior$_updateTextBox$1(item, index) {
        this._stopTimer$1();
        this._hideDropDown$1();
        var text = null;
        var selectedHandler = this.get_events().getHandler('itemSelected');
        if (selectedHandler) {
            var e = new ScriptFX.UI.AutoCompleteItemEventArgs(item, index);
            selectedHandler.invoke(this, e);
            text = e.get_text();
        }
        if (!text) {
            text = item;
        }
        this._currentPrefix$1 = text;
        (this.get_domElement()).value = text;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteItemEventArgs

ScriptFX.UI.AutoCompleteItemEventArgs = function ScriptFX_UI_AutoCompleteItemEventArgs(item, index) {
    ScriptFX.UI.AutoCompleteItemEventArgs.constructBase(this);
    this._item$1 = item;
    this._index$1 = index;
}
ScriptFX.UI.AutoCompleteItemEventArgs.prototype = {
    _item$1: null,
    _index$1: 0,
    _text$1: null,
    
    get_index: function ScriptFX_UI_AutoCompleteItemEventArgs$get_index() {
        return this._index$1;
    },
    
    get_item: function ScriptFX_UI_AutoCompleteItemEventArgs$get_item() {
        return this._item$1;
    },
    
    get_text: function ScriptFX_UI_AutoCompleteItemEventArgs$get_text() {
        return this._text$1;
    },
    set_text: function ScriptFX_UI_AutoCompleteItemEventArgs$set_text(value) {
        this._text$1 = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.AutoCompleteRequestEventArgs

ScriptFX.UI.AutoCompleteRequestEventArgs = function ScriptFX_UI_AutoCompleteRequestEventArgs(prefixText) {
    ScriptFX.UI.AutoCompleteRequestEventArgs.constructBase(this);
    this._prefixText$1 = prefixText;
}
ScriptFX.UI.AutoCompleteRequestEventArgs.prototype = {
    _prefixText$1: null,
    _items$1: null,
    
    get__items: function ScriptFX_UI_AutoCompleteRequestEventArgs$get__items() {
        return this._items$1;
    },
    
    get_prefixText: function ScriptFX_UI_AutoCompleteRequestEventArgs$get_prefixText() {
        return this._prefixText$1;
    },
    
    setItems: function ScriptFX_UI_AutoCompleteRequestEventArgs$setItems(items) {
        this._items$1 = items;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Button

ScriptFX.UI.Button = function ScriptFX_UI_Button(domElement) {
    ScriptFX.UI.Button.constructBase(this, [ domElement ]);
    this.get_domEvents().attach('onclick', Delegate.create(this, this._onClick$2));
}
ScriptFX.UI.Button.prototype = {
    _actionArgument$2: null,
    _actionName$2: null,
    
    get_actionArgument: function ScriptFX_UI_Button$get_actionArgument() {
        return this._actionArgument$2;
    },
    set_actionArgument: function ScriptFX_UI_Button$set_actionArgument(value) {
        this._actionArgument$2 = value;
        return value;
    },
    
    get_actionName: function ScriptFX_UI_Button$get_actionName() {
        return this._actionName$2;
    },
    set_actionName: function ScriptFX_UI_Button$set_actionName(value) {
        this._actionName$2 = value;
        return value;
    },
    
    add_action: function ScriptFX_UI_Button$add_action(value) {
        this.get_events().addHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    remove_action: function ScriptFX_UI_Button$remove_action(value) {
        this.get_events().removeHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    
    add_click: function ScriptFX_UI_Button$add_click(value) {
        this.get_events().addHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    remove_click: function ScriptFX_UI_Button$remove_click(value) {
        this.get_events().removeHandler(ScriptFX.UI.Button._clickEventKey$2, value);
    },
    
    _onClick$2: function ScriptFX_UI_Button$_onClick$2() {
        var clickHandler = this.get_events().getHandler(ScriptFX.UI.Button._clickEventKey$2);
        if (clickHandler) {
            clickHandler.invoke(this, EventArgs.Empty);
        }
    },
    
    performClick: function ScriptFX_UI_Button$performClick() {
        this._onClick$2();
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.CheckBox

ScriptFX.UI.CheckBox = function ScriptFX_UI_CheckBox(domElement) {
    ScriptFX.UI.CheckBox.constructBase(this, [ domElement ]);
    this.get_domEvents().attach('onclick', Delegate.create(this, this._onClick$2));
}
ScriptFX.UI.CheckBox.prototype = {
    
    get_checked: function ScriptFX_UI_CheckBox$get_checked() {
        return (this.get_domElement()).checked;
    },
    set_checked: function ScriptFX_UI_CheckBox$set_checked(value) {
        (this.get_domElement()).checked = value;
        return value;
    },
    
    add_checkedChanged: function ScriptFX_UI_CheckBox$add_checkedChanged(value) {
        this.get_events().addHandler(ScriptFX.UI.CheckBox._checkChangedEventKey$2, value);
    },
    remove_checkedChanged: function ScriptFX_UI_CheckBox$remove_checkedChanged(value) {
        this.get_events().removeHandler(ScriptFX.UI.CheckBox._checkChangedEventKey$2, value);
    },
    
    _onClick$2: function ScriptFX_UI_CheckBox$_onClick$2() {
        var checkChangedHandler = this.get_events().getHandler(ScriptFX.UI.CheckBox._checkChangedEventKey$2);
        if (checkChangedHandler) {
            checkChangedHandler.invoke(this, EventArgs.Empty);
        }
        this.raisePropertyChanged('Checked');
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.EnterKeyBehavior

ScriptFX.UI.EnterKeyBehavior = function ScriptFX_UI_EnterKeyBehavior(element, options) {
    ScriptFX.UI.EnterKeyBehavior.constructBase(this, [ element, null ]);
    this._clickTarget$1 = options.clickTarget;
    this.get_domEvents().attach('onkeypress', Delegate.create(this, this._onElementKeyPress$1));
}
ScriptFX.UI.EnterKeyBehavior.prototype = {
    _clickTarget$1: null,
    
    _onElementKeyPress$1: function ScriptFX_UI_EnterKeyBehavior$_onElementKeyPress$1() {
        if ((window.event.keyCode === ScriptFX.UI.Key.enter) && (!this._clickTarget$1.disabled)) {
            window.event.cancelBubble = true;
            window.event.returnValue = false;
            this._clickTarget$1.click();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.Label

ScriptFX.UI.Label = function ScriptFX_UI_Label(domElement) {
    ScriptFX.UI.Label.constructBase(this, [ domElement ]);
}
ScriptFX.UI.Label.prototype = {
    
    get_text: function ScriptFX_UI_Label$get_text() {
        return this.get_domElement().innerText;
    },
    set_text: function ScriptFX_UI_Label$set_text(value) {
        this.get_domElement().innerText = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.TextBox

ScriptFX.UI.TextBox = function ScriptFX_UI_TextBox(domElement) {
    ScriptFX.UI.TextBox.constructBase(this, [ domElement ]);
    this.get_domEvents().attach('onchange', Delegate.create(this, this._onValueChanged$2));
}
ScriptFX.UI.TextBox.prototype = {
    
    get_text: function ScriptFX_UI_TextBox$get_text() {
        var watermark = ScriptFX.UI.Behavior.getBehavior(this.get_domElement(), ScriptFX.UI.WatermarkBehavior);
        if ((watermark) && watermark.get_isWatermarked()) {
            return String.Empty;
        }
        return (this.get_domElement()).value;
    },
    set_text: function ScriptFX_UI_TextBox$set_text(value) {
        (this.get_domElement()).value = value;
        this._onValueChanged$2();
        return value;
    },
    
    add_textChanged: function ScriptFX_UI_TextBox$add_textChanged(value) {
        this.get_events().addHandler(ScriptFX.UI.TextBox._textChangedEventKey$2, value);
    },
    remove_textChanged: function ScriptFX_UI_TextBox$remove_textChanged(value) {
        this.get_events().removeHandler(ScriptFX.UI.TextBox._textChangedEventKey$2, value);
    },
    
    _onValueChanged$2: function ScriptFX_UI_TextBox$_onValueChanged$2() {
        var textChangedHandler = this.get_events().getHandler(ScriptFX.UI.TextBox._textChangedEventKey$2);
        if (textChangedHandler) {
            textChangedHandler.invoke(this, EventArgs.Empty);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.UI.WatermarkBehavior

ScriptFX.UI.WatermarkBehavior = function ScriptFX_UI_WatermarkBehavior(element, options) {
    ScriptFX.UI.WatermarkBehavior.constructBase(this, [ element, null ]);
    this._options$1 = options;
    this.get_domEvents().attach('onfocus', Delegate.create(this, this._onElementFocus$1));
    this.get_domEvents().attach('onblur', Delegate.create(this, this._onElementBlur$1));
    this.update();
}
ScriptFX.UI.WatermarkBehavior.prototype = {
    _options$1: null,
    _maxLength$1: 0,
    
    get_isWatermarked: function ScriptFX_UI_WatermarkBehavior$get_isWatermarked() {
        return ScriptFX.UI.Element.containsCSSClass(this.get_domElement(), this._options$1.watermarkCssClass);
    },
    
    _applyWatermark$1: function ScriptFX_UI_WatermarkBehavior$_applyWatermark$1() {
        var element = this.get_domElement();
        if (!element.value.length) {
            this._maxLength$1 = element.maxLength;
            element.maxLength = this._options$1.watermarkText.length;
            ScriptFX.UI.Element.addCSSClass(element, this._options$1.watermarkCssClass);
            element.value = this._options$1.watermarkText;
        }
    },
    
    _clearWatermark$1: function ScriptFX_UI_WatermarkBehavior$_clearWatermark$1(focusing) {
        var element = this.get_domElement();
        if (ScriptFX.UI.Element.containsCSSClass(element, this._options$1.watermarkCssClass)) {
            element.maxLength = this._maxLength$1;
            ScriptFX.UI.Element.removeCSSClass(element, this._options$1.watermarkCssClass);
            if (focusing) {
                element.value = '';
            }
        }
    },
    
    dispose: function ScriptFX_UI_WatermarkBehavior$dispose() {
        if (!this.get_isDisposed()) {
            this._clearWatermark$1(false);
        }
        ScriptFX.UI.WatermarkBehavior.callBase(this, 'dispose');
    },
    
    _onElementFocus$1: function ScriptFX_UI_WatermarkBehavior$_onElementFocus$1() {
        this._clearWatermark$1(true);
    },
    
    _onElementBlur$1: function ScriptFX_UI_WatermarkBehavior$_onElementBlur$1() {
        this._applyWatermark$1();
    },
    
    update: function ScriptFX_UI_WatermarkBehavior$update() {
        var element = this.get_domElement();
        if (!element.value.length) {
            this._applyWatermark$1();
        }
        else {
            this._clearWatermark$1(false);
        }
    }
}


ScriptFX.UI.AutoCompleteBehavior.createClass('ScriptFX.UI.AutoCompleteBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.AutoCompleteItemEventArgs.createClass('ScriptFX.UI.AutoCompleteItemEventArgs', EventArgs);
ScriptFX.UI.AutoCompleteRequestEventArgs.createClass('ScriptFX.UI.AutoCompleteRequestEventArgs', EventArgs);
ScriptFX.UI.Button.createClass('ScriptFX.UI.Button', ScriptFX.UI.Control, ScriptFX.UI.IAction);
ScriptFX.UI.CheckBox.createClass('ScriptFX.UI.CheckBox', ScriptFX.UI.Control, ScriptFX.UI.IToggle);
ScriptFX.UI.EnterKeyBehavior.createClass('ScriptFX.UI.EnterKeyBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.Label.createClass('ScriptFX.UI.Label', ScriptFX.UI.Control, ScriptFX.UI.IStaticText);
ScriptFX.UI.TextBox.createClass('ScriptFX.UI.TextBox', ScriptFX.UI.Control, ScriptFX.UI.IEditableText);
ScriptFX.UI.WatermarkBehavior.createClass('ScriptFX.UI.WatermarkBehavior', ScriptFX.UI.Behavior);
ScriptFX.UI.Button._clickEventKey$2 = 'click';
ScriptFX.UI.CheckBox._checkChangedEventKey$2 = 'checkChanged';
ScriptFX.UI.TextBox._textChangedEventKey$2 = 'textChanged';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
// Script# Framework
// Copyright (c) 2007, Nikhil Kothari. All Rights Reserved.
// http://projects.nikhilk.net
//


Type.createNamespace('ScriptFX.Net');

////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net._scriptResponse

ScriptFX.Net._scriptResponse = function ScriptFX_Net__scriptResponse(request, data) {
    this._timeStamp = new Date();
    this._request = request;
    this._data = data;
}
ScriptFX.Net._scriptResponse.prototype = {
    _request: null,
    _timeStamp: null,
    _data: null,
    _xml: null,
    
    get_contentLength: function ScriptFX_Net__scriptResponse$get_contentLength() {
        return 0;
    },
    
    get_contentType: function ScriptFX_Net__scriptResponse$get_contentType() {
        return 'text/javascript';
    },
    
    get_headers: function ScriptFX_Net__scriptResponse$get_headers() {
        return {};
    },
    
    get_request: function ScriptFX_Net__scriptResponse$get_request() {
        return this._request;
    },
    
    get_statusCode: function ScriptFX_Net__scriptResponse$get_statusCode() {
        return ScriptFX.Net.HTTPStatusCode.OK;
    },
    
    get_statusText: function ScriptFX_Net__scriptResponse$get_statusText() {
        return String.Empty;
    },
    
    get_timeStamp: function ScriptFX_Net__scriptResponse$get_timeStamp() {
        return this._timeStamp;
    },
    
    getHeader: function ScriptFX_Net__scriptResponse$getHeader(name) {
        return null;
    },
    
    getObject: function ScriptFX_Net__scriptResponse$getObject() {
        return this._data;
    },
    
    getText: function ScriptFX_Net__scriptResponse$getText() {
        return Type.safeCast(this._data, String);
    },
    
    getXML: function ScriptFX_Net__scriptResponse$getXML() {
        if (!this._xml) {
            var text = this.getText();
            if (text) {
                try {
                    this._xml = XMLDocumentParser.parse(text);
                }
                catch ($e1) {
                }
            }
        }
        return this._xml;
    }
}


////////////////////////////////////////////////////////////////////////////////
// ScriptFX.Net.ScriptTransport

ScriptFX.Net.ScriptTransport = function ScriptFX_Net_ScriptTransport(request) {
    ScriptFX.Net.ScriptTransport.constructBase(this, [ request ]);
}
ScriptFX.Net.ScriptTransport.prototype = {
    _scriptElement$1: null,
    _callbackExport$1: null,
    
    abort: function ScriptFX_Net_ScriptTransport$abort() {
        if (this._callbackExport$1) {
            Delegate.clearExport(this._callbackExport$1);
            this._callbackExport$1 = null;
        }
        if (this._scriptElement$1) {
            document.body.removeChild(this._scriptElement$1);
            this._scriptElement$1 = null;
        }
    },
    
    dispose: function ScriptFX_Net_ScriptTransport$dispose() {
        this.abort();
    },
    
    invoke: function ScriptFX_Net_ScriptTransport$invoke() {
        Debug.assert(this.getMethod() === 'GET');
        Debug.assert(!this.get_request().get_hasHeaders());
        Debug.assert(!this.get_request().get_hasCredentials());
        var callbackParam = null;
        var parameters = this.get_parameters();
        if (parameters) {
            callbackParam = parameters['callbackParameterName'];
        }
        if (!callbackParam) {
            callbackParam = 'callback';
        }
        var callback = Delegate.create(this, this._onDataAvailable$1);
        this._callbackExport$1 = Delegate.createExport(callback);
        var callbackCode = callbackParam + '=Delegate.' + this._callbackExport$1;
        var url = this.get_request().get_URI();
        if (url.indexOf('?') >= 0) {
            url += '&' + callbackCode;
        }
        else {
            url += '?' + callbackCode;
        }
        this._scriptElement$1 = document.createElement('SCRIPT');
        this._scriptElement$1.type = 'text/javascript';
        this._scriptElement$1.src = url;
        document.body.appendChild(this._scriptElement$1);
    },
    
    _onDataAvailable$1: function ScriptFX_Net_ScriptTransport$_onDataAvailable$1(data) {
        if (this._scriptElement$1) {
            document.body.removeChild(this._scriptElement$1);
            this._scriptElement$1 = null;
            this._callbackExport$1 = null;
            this.onCompleted(new ScriptFX.Net._scriptResponse(this.get_request(), data));
        }
    }
}


ScriptFX.Net._scriptResponse.createClass('ScriptFX.Net._scriptResponse', null, ScriptFX.Net.IHTTPResponse);
ScriptFX.Net.ScriptTransport.createClass('ScriptFX.Net.ScriptTransport', ScriptFX.Net.HTTPTransport);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('Framework');

Framework.XMLUtils = function() {
}

Framework.XMLUtils.prototype = {
	_emptyContentDocument : null
}

Framework.XMLUtils.transformAndUpdateFirefox = function XMLUtils$transformAndUpdateFirefox(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback) {
	var xsltProcessor = new XSLTProcessor();
	for (var parameterName in parametersMap)
		if (parameterName != null && parametersMap[parameterName] != null)
			xsltProcessor.setParameter("", parameterName, parametersMap[parameterName]);
	xsltProcessor.importStylesheet(xsltDocument);
	var resultFragment = xsltProcessor.transformToFragment(contentDocument, document);
	var placeHolder = (domElement == null) ? $(domElementId) : domElement;

	if (placeHolder != null) {
	    // create garbage collector
	    var GCid = 'GarbageCollector';
	    if (document.getElementById(GCid) == null) {
	        var GC = document.createElement("div");
	        GC.setAttribute('id', GCid);
	        GC.style.display = 'none';
	        window.document.body.appendChild(GC);
	    }
	    var GC = document.getElementById(GCid);
	    // put new content into memory
	    var newContent = document.createElement("div");
	    GC.appendChild(newContent);
		newContent.appendChild(resultFragment);
		
		// execute in memory callback
		if(inMemoryProcessingCallback != null)
		    inMemoryProcessingCallback(newContent);
		
		// move old content away
		var oldContent = document.createElement("div");
		GC.appendChild(oldContent);
		while(placeHolder.childNodes.length)
			oldContent.appendChild(placeHolder.childNodes[0]);
		
		// add new content to screen
		while(newContent.childNodes.length)
			placeHolder.appendChild(newContent.childNodes[0]);
		
		// remove behaviors	from old content
		Framework.DocumentBehaviors.purgeBehaviors(oldContent, true, 0);
		GC.innerHTML = '';
		oldContent = null;
		newContent = null;	
	}
}

Framework.XMLUtils.transformAndUpdateInternetExplorer = function XMLUtils$transformAndUpdateInternetExplorer(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback) {

    //Made a change here to use MSXML instead of the default version
    //This was done so that the <xslt:include> state works in IE. Otherwise it gives an access denied error
    
    var freeThreadedXsltDocument = new ActiveXObject("MSXML2.FreeThreadedDOMDocument.6.0");
    freeThreadedXsltDocument.resolveExternals = true;
    freeThreadedXsltDocument.setProperty("AllowDocumentFunction", true);
    freeThreadedXsltDocument.setProperty("ProhibitDTD", false);
    
    xsltDocument.resolveExternals = true;
    xsltDocument.setProperty("AllowDocumentFunction", true);
    xsltDocument.setProperty("ProhibitDTD", false);
    
    freeThreadedXsltDocument.loadXML(xsltDocument.xml);
    var cache = new ActiveXObject("MSXML2.XSLTemplate.6.0");
    cache.stylesheet = freeThreadedXsltDocument;
    var processor = cache.createProcessor();
    for (var parameterName in parametersMap)
        if (parameterName != null && parametersMap[parameterName] != null)
        processor.addParameter(parameterName, parametersMap[parameterName]);
    processor.input = contentDocument;
    processor.transform();

    var placeHolder = (domElement == null) ? $(domElementId) : domElement;
    if (placeHolder != null) {
        // create garbage collector
        var GCid = 'GarbageCollector';
        if (document.getElementById(GCid) == null) {
            var GC = document.createElement("div");
            GC.setAttribute('id', GCid);
            GC.style.display = 'none';
            window.document.body.appendChild(GC);
        }
        var GC = document.getElementById(GCid);
        // put new content into memory
        var newContent = document.createElement("div");
        GC.appendChild(newContent);
        newContent.innerHTML = processor.output;

        // execute in memory callback
        if (inMemoryProcessingCallback != null)
            inMemoryProcessingCallback(newContent);

        // move old content to GC bin
        var oldContent = document.createElement("div");
        GC.appendChild(oldContent);
        while (placeHolder.childNodes.length)
            oldContent.appendChild(placeHolder.childNodes[0]);

        // add new content to screen
        while (newContent.childNodes.length)
            placeHolder.appendChild(newContent.childNodes[0]);

        // remove behaviors	
        Framework.DocumentBehaviors.purgeBehaviors(oldContent, true, 0);
        GC.innerHTML = '';
        oldContent = null;
        newContent = null;
    }
}

Framework.XMLUtils.transformAndUpdateInternetExplorerWithXsltUrl = function XMLUtils$transformAndUpdateInternetExplorerWithXsltUrl(contentDocument, xsltDocument, parametersMap, domElementId, domElement, xsltUrl, inMemoryProcessingCallback) {

    //Made a change here to use MSXML instead of the default version
    //This was done so that the <xslt:include> state works in IE. Otherwise it gives an access denied error

    var freeThreadedXsltDocument = new ActiveXObject("MSXML2.FreeThreadedDOMDocument.6.0");
    freeThreadedXsltDocument.resolveExternals = true;
    freeThreadedXsltDocument.setProperty("AllowDocumentFunction", true);
    freeThreadedXsltDocument.setProperty("ProhibitDTD", false);
    
    xsltDocument.resolveExternals = true;
    xsltDocument.setProperty("AllowDocumentFunction", true);
    xsltDocument.setProperty("ProhibitDTD", false);

    if (xsltDocument == null)
        freeThreadedXsltDocument.load(xsltUrl);
    else
        freeThreadedXsltDocument.loadXML(xsltDocument.xml);
    var cache = new ActiveXObject("MSXML2.XSLTemplate.6.0");
    cache.stylesheet = freeThreadedXsltDocument;
    var processor = cache.createProcessor();
    for (var parameterName in parametersMap)
        if (parameterName != null && parametersMap[parameterName] != null)
        processor.addParameter(parameterName, parametersMap[parameterName]);
    processor.input = contentDocument;
    processor.transform();

    var placeHolder = (domElement == null) ? $(domElementId) : domElement;
    if (placeHolder != null) {
        // create garbage collector
        var GCid = 'GarbageCollector';
        if (document.getElementById(GCid) == null) {
            var GC = document.createElement("div");
            GC.setAttribute('id', GCid);
            GC.style.display = 'none';
            window.document.body.appendChild(GC);
        }
        var GC = document.getElementById(GCid);
        // put new content into memory
        var newContent = document.createElement("div");
        GC.appendChild(newContent);
        newContent.innerHTML = processor.output;

        // execute in memory callback
        if (inMemoryProcessingCallback != null)
            inMemoryProcessingCallback(newContent);

        // move old content to GC bin
        var oldContent = document.createElement("div");
        GC.appendChild(oldContent);
        while (placeHolder.childNodes.length)
            oldContent.appendChild(placeHolder.childNodes[0]);

        // add new content to screen
        while (newContent.childNodes.length)
            placeHolder.appendChild(newContent.childNodes[0]);

        // remove behaviors	
        Framework.DocumentBehaviors.purgeBehaviors(oldContent, true, 0);
        GC.innerHTML = '';
        oldContent = null;
        newContent = null;
    }
}

Framework.XMLUtils.transformAndUpdate = function XMLUtils$transformAndUpdate(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback) {
	if (document.implementation && document.implementation.createDocument)
		this.transformAndUpdateFirefox(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback);
	else
		this.transformAndUpdateInternetExplorer(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback);
}

Framework.XMLUtils.transformAndUpdateWithXsltUrl = function XMLUtils$transformAndUpdateWithXsltUrl(contentDocument, xsltDocument, parametersMap, domElementId, domElement, xsltUrl, inMemoryProcessingCallback) {
    if (document.implementation && document.implementation.createDocument)
        this.transformAndUpdateFirefox(contentDocument, xsltDocument, parametersMap, domElementId, domElement, inMemoryProcessingCallback);
    else
        this.transformAndUpdateInternetExplorerWithXsltUrl(contentDocument, xsltDocument, parametersMap, domElementId, domElement, xsltUrl, inMemoryProcessingCallback);
}


Framework.XMLUtils.get_emptyContentDocument = function XMLUtils$get_emptyContentDocument() {
	if (!this._emptyContentDocument)
		if (document.implementation && document.implementation.createDocument)
			this._emptyContentDocument = document.implementation.createDocument("", "no-content", null); 
		else {
			this._emptyContentDocument = new ActiveXObject("MSXML2.FreeThreadedDOMDocument");
			this._emptyContentDocument.loadXML("<no-content />");
		}
	return this._emptyContentDocument;
}

//////////

Framework.HtmlUtils = function() {
}

Framework.HtmlUtils.prototype = {
	_emptyContentDocument : null
}

Framework.HtmlUtils.detachBehavioursAndClearHtmlElementContent = function HtmlUtils$detachBehavioursAndClearHtmlElementContent(domElementId){
	var domElement = document.getElementById(domElementId);
	
	if(domElement == null)
	    return;
	    
    Framework.DocumentBehaviors.purgeBehaviors(domElement, false, 0);
    domElement.innerHTML = "";
    domElement.parentNode.removeChild(domElement);
}


//////////
/*
    The global object JSON contains two methods.

    JSON.stringify(value) takes a JavaScript value and produces a JSON text.
    The value must not be cyclical.

    JSON.parse(text) takes a JSON text and produces a JavaScript value. It will
    return false if there is an error.
*/
var JSON1 = function () {
    var m = {
            '\b': '\\b',
            '\t': '\\t',
            '\n': '\\n',
            '\f': '\\f',
            '\r': '\\r',
            '"' : '\\"',
            '\\': '\\\\'
        },
        s = {
            'boolean': function (x) {
                return String(x);
            },
            number: function (x) {
                return isFinite(x) ? String(x) : 'null';
            },
            string: function (x) {
                if (/["\\\x00-\x1f]/.test(x)) {
                    x = x.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 '"' + x + '"';
            },
            object: function (x) {
                if (x) {
                    var a = [], b, f, i, l, v;
                    if (x instanceof Array) {
                        a[0] = '[';
                        l = x.length;
                        for (i = 0; i < l; i += 1) {
                            v = x[i];
                            f = s[typeof v];
                            if (f) {
                                v = f(v);
                                if (typeof v == 'string') {
                                    if (b) {
                                        a[a.length] = ',';
                                    }
                                    a[a.length] = v;
                                    b = true;
                                }
                            }
                        }
                        a[a.length] = ']';
                    } else if (x instanceof Object) {
                        a[0] = '{';
                        for (i in x) {
                            v = x[i];
                            f = s[typeof v];
                            if (f) {
                                v = f(v);
                                if (typeof v == 'string') {
                                    if (b) {
                                        a[a.length] = ',';
                                    }
                                    a.push(s.string(i), ':', v);
                                    b = true;
                                }
                            }
                        }
                        a[a.length] = '}';
                    } else {
                        return;
                    }
                    return a.join('');
                }
                return 'null';
            }
        };
    return {
        copyright: '(c)2005 JSON.org',
        license: 'http://www.crockford.com/JSON/license.html',
/*
    Stringify a JavaScript value, producing a JSON text.
*/
        stringify: function (v) {
            var f = s[typeof v];
            if (f) {
                v = f(v);
                if (typeof v == 'string') {
                    return v;
                }
            }
            return null;
        },
/*
    Parse a JSON text, producing a JavaScript value.
    It returns false if there is a syntax error.
*/
        eval: function (text) {
            try {
                return !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
                        text.replace(/"(\\.|[^"\\])*"/g, ''))) &&
                    eval('(' + text + ')');
            } catch (e) {
                return false;
            }
        },

        parse: function (text) {
            var at = 0;
            var ch = ' ';

            function error(m) {
                throw {
                    name: 'JSONError',
                    message: m,
                    at: at - 1,
                    text: text
                };
            }

            function next() {
                ch = text.charAt(at);
                at += 1;
                return ch;
            }

            function white() {
                while (ch) {
                    if (ch <= ' ') {
                        next();
                    } else if (ch == '/') {
                        switch (next()) {
                            case '/':
                                while (next() && ch != '\n' && ch != '\r') {}
                                break;
                            case '*':
                                next();
                                for (;;) {
                                    if (ch) {
                                        if (ch == '*') {
                                            if (next() == '/') {
                                                next();
                                                break;
                                            }
                                        } else {
                                            next();
                                        }
                                    } else {
                                        error("Unterminated comment");
                                    }
                                }
                                break;
                            default:
                                error("Syntax error");
                        }
                    } else {
                        break;
                    }
                }
            }

            function string() {
                var i, s = '', t, u;

                if (ch == '"') {
    outer:          while (next()) {
                        if (ch == '"') {
                            next();
                            return s;
                        } else if (ch == '\\') {
                            switch (next()) {
                            case 'b':
                                s += '\b';
                                break;
                            case 'f':
                                s += '\f';
                                break;
                            case 'n':
                                s += '\n';
                                break;
                            case 'r':
                                s += '\r';
                                break;
                            case 't':
                                s += '\t';
                                break;
                            case 'u':
                                u = 0;
                                for (i = 0; i < 4; i += 1) {
                                    t = parseInt(next(), 16);
                                    if (!isFinite(t)) {
                                        break outer;
                                    }
                                    u = u * 16 + t;
                                }
                                s += String.fromCharCode(u);
                                break;
                            default:
                                s += ch;
                            }
                        } else {
                            s += ch;
                        }
                    }
                }
                error("Bad string");
            }

            function array() {
                var a = [];

                if (ch == '[') {
                    next();
                    white();
                    if (ch == ']') {
                        next();
                        return a;
                    }
                    while (ch) {
                        a.push(value());
                        white();
                        if (ch == ']') {
                            next();
                            return a;
                        } else if (ch != ',') {
                            break;
                        }
                        next();
                        white();
                    }
                }
                error("Bad array");
            }

            function object() {
                var k, o = {};

                if (ch == '{') {
                    next();
                    white();
                    if (ch == '}') {
                        next();
                        return o;
                    }
                    while (ch) {
                        k = string();
                        white();
                        if (ch != ':') {
                            break;
                        }
                        next();
                        o[k] = value();
                        white();
                        if (ch == '}') {
                            next();
                            return o;
                        } else if (ch != ',') {
                            break;
                        }
                        next();
                        white();
                    }
                }
                error("Bad object");
            }

            function number() {
                var n = '', v;
                if (ch == '-') {
                    n = '-';
                    next();
                }
                while (ch >= '0' && ch <= '9') {
                    n += ch;
                    next();
                }
                if (ch == '.') {
                    n += '.';
                    while (next() && ch >= '0' && ch <= '9') {
                        n += ch;
                    }
                }
                if (ch == 'e' || ch == 'E') {
                    n += 'e';
                    next();
                    if (ch == '-' || ch == '+') {
                        n += ch;
                        next();
                    }
                    while (ch >= '0' && ch <= '9') {
                        n += ch;
                        next();
                    }
                }
                v = +n;
                if (!isFinite(v)) {
                    ////error("Bad number");
                } else {
                    return v;
                }
            }

            function word() {
                switch (ch) {
                    case 't':
                        if (next() == 'r' && next() == 'u' && next() == 'e') {
                            next();
                            return true;
                        }
                        break;
                    case 'f':
                        if (next() == 'a' && next() == 'l' && next() == 's' &&
                                next() == 'e') {
                            next();
                            return false;
                        }
                        break;
                    case 'n':
                        if (next() == 'u' && next() == 'l' && next() == 'l') {
                            next();
                            return null;
                        }
                        break;
                }
                error("Syntax error");
            }

            function value() {
                white();
                switch (ch) {
                    case '{':
                        return object();
                    case '[':
                        return array();
                    case '"':
                        return string();
                    case '-':
                        return number();
                    default:
                        return ch >= '0' && ch <= '9' ? number() : word();
                }
            }

            return value();
        }
    };
}();

Framework.JsonUtil = function() {
}

Framework.JsonUtil.serialize = function serialize(value) {
	return JSON1.stringify(value);
}

Framework.JsonUtil.deserialize = function deserialize(text) {
	return JSON1.parse(text);
}

Framework.DocumentEvents = function() {
}

Framework.DocumentEvents.setOnMousemove = function(handler){
	document.onmousemove	= handler;
}

Framework.DocumentEvents.setOnMouseup = function(handler){
	document.onmouseup	= handler;
}

Framework.DocumentEvents.parse = function(handler) {
	return handler;
}

Framework.DocumentEvents.purgeEventsBeforeUpdate = function(d,ignoreRootElement, recursionCount) {
	if (recursionCount > 100)
		return;
		
	var index1;
	if(!ignoreRootElement)
	{
	    var behaviors = ScriptFX.UI.Behavior.getBehaviors(d, null);
	    if(behaviors)
	    {
	        for (index1 = 0; index1 < behaviors.length; index1++)
	        {
	            behaviors[index1].dispose();
            }
	    }
	}
		
	var i;
	if (!ignoreRootElement && d.attributes)
		for (i = 0; i < d.attributes.length; i++)
		try {
			if (typeof d[d.attributes[i].name] === 'function')
				d[d.attributes[i].name] = null;
		} catch(e){
			alert(e + 'Please contact customer support!');
		}
	var i;
	if (d.childNodes)
		for (i = 0; i < d.childNodes.length; i++)
			Framework.DocumentEvents.purgeEventsBeforeUpdate(d.childNodes[i], false, recursionCount + 1);
}

Framework.DocumentBehaviors = function() {
}

// Remove behaviors from all DOM elements recursively
Framework.DocumentBehaviors.purgeBehaviors = function(d,ignoreRootElement, recursionCount) {
	if (recursionCount > 100)
		return;
	
	var index1;
	if(!ignoreRootElement)
	{
	    var behaviors = ScriptFX.UI.Behavior.getBehaviors(d, null);
	    if(behaviors)
	    {
	        for (index1 = 0; index1 < behaviors.length; index1++)
	        {
	            behaviors[index1].dispose();
            }
	    }
	}
	
	var index2;
	if (d.childNodes)
	{
		for (index2 = 0; index2 < d.childNodes.length; index2++)
			Framework.DocumentBehaviors.purgeBehaviors(d.childNodes[index2], false, recursionCount + 1);
	}
}


Type.createNamespace('Framework.Behavior');

Framework.Behavior.ParametersObjectBuilder = function() {
}

Framework.Behavior.ParametersObjectBuilder.build = function(domElement, behaviorID) {
	if (domElement.attributes == null)
	    return null;
	
	var pattern = new RegExp("^behavior." + behaviorID + ".","i");
	var parameters = new Array();
	var i;
	for (i = 0; i < domElement.attributes.length; i++)
    {
        var attname = domElement.attributes[i].name;
        
        if(attname.search(pattern) == -1)
            continue;
        
        parameters[attname.replace(pattern,"")] = domElement.attributes[i].value;    
    }
    
    return parameters;
}


Type.createNamespace('Framework.Util');

Framework.Util.DebugInfoProvider = function() {
}

Framework.Util.DebugInfoProvider.delegateDebugInfo = function(parDelegate) {
    var result = "";
    
    if(parDelegate != null && 
        parDelegate._targets != null && 
        parDelegate._targets.length != null && 
        parDelegate._targets.length == 2)
    {
        if(parDelegate._targets[1] != null)
            result = parDelegate._targets[1].toString();
    }
    
    return result;
}


/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	WindowedControlsHider.js - Windowed Controls Hider v3.20
	aplus.co.yu/WindowedControlsHider/
	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	(c) Copyright 2003 and on, Aleksandar Vacic, www.aplus.co.yu
		This work is licensed under the Creative Commons Attribution License.
		To view a copy of this license, visit http://creativecommons.org/licenses/by/3.0/ or
		send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
var WCH_Constructor = function() {
	//	exit point for anything but IE5.0+/Win
	if ( !(document.all && document.getElementById && !window.opera && navigator.userAgent.toLowerCase().indexOf("mac") == -1) ) {
		this.apply = function() {};
		this.discard = function() {};
		return;
	}

	//	private properties
	var _bIE55 = false;
	var _bIE6 = false;
	var _oRule = null;
	var _bSetup = true;
	var _oSelf = this;

	//	public: hides windowed controls
	this.apply = function(vLayer, vContainer, bResize) {
		if (_bSetup) _Setup();

		if ( _bIE55 && (oIframe = _Hider(vLayer, vContainer, bResize)) ) {
			oIframe.style.visibility = "visible";
		} else if(_oRule != null) {
			_oRule.style.visibility = "hidden";
		}

	};

	//	public: shows windowed controls
	this.discard = function(vLayer, vContainer) {
		if ( _bIE55 && (oIframe = _Hider(vLayer, vContainer, false)) ) {
			oIframe.style.visibility = "hidden";
		} else if(_oRule != null) {
			_oRule.style.visibility = "visible";
		}
	};

	//	private: returns iFrame reference for IE5.5+
	function _Hider(vLayer, vContainer, bResize) {
		var oLayer = _GetObj(vLayer);
		var oContainer = ( (oTmp = _GetObj(vContainer)) ? oTmp : document.getElementsByTagName("body")[0] );
		if (!oLayer || !oContainer) return;

		//	is it there already?
		//		1. first check does the layer has an ID at all. if not, assign one, using current timestamp, so we avoid duplicates
		if (oLayer.id == "")
			oLayer.id = "WCHid" + (new Date()).getTime();
		//		2. then try to locate the hiding iFrame
		var oIframe = document.getElementById("WCHhider" + oLayer.id);

		//	if not, create it
		if ( !oIframe ) {
			//	IE 6 has this property, IE 5 not. IE 5.5(even SP2) crashes when filter is applied, hence the check
			var sFilter = (_bIE6) ? "filter:progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0);" : "";
			//	get z-index of the object
			var zIndex = oLayer.style.zIndex;
			if ( zIndex == "" ) zIndex = oLayer.currentStyle.zIndex;
			zIndex = parseInt(zIndex);
			//	if no z-index, do nothing
			if ( isNaN(zIndex) ) return null;
			//	if z-index is below 2, do nothing (no room for Hider)
			if (zIndex < 2) return null;
			//	go one step below for Hider
			zIndex--;
			var sHiderID = "WCHhider" + oLayer.id;
			oContainer.insertAdjacentHTML("afterBegin", '<iframe class="WCHiframe" src="javascript:void(0);" id="' + sHiderID + '" scroll="no" frameborder="0" style="position:absolute;visibility:hidden;' + sFilter + 'border:0;top:0;left;0;width:0;height:0;background-color:#ccc;z-index:' + zIndex + ';"></iframe>');
			oIframe = document.getElementById(sHiderID);
			//	then do calculation
			_SetPos(oIframe, oLayer);
		} else if (bResize) {
			//	resize the iFrame if asked
			_SetPos(oIframe, oLayer);
		}
		return oIframe;
	};

	//	private: set size and position of the Hider
	function _SetPos(oIframe, oLayer) {
		//	fetch and set size
		oIframe.style.width = oLayer.offsetWidth + "px";
		oIframe.style.height = oLayer.offsetHeight + "px";
		//	move to specified position
		oIframe.style.left = oLayer.offsetLeft + "px";
		oIframe.style.top = oLayer.offsetTop + "px";
	};

	//	private: returns object reference
	function _GetObj(vObj) {
		var oObj = null;
		switch( typeof(vObj) ) {
			case "object":
				oObj = vObj;
				break;
			case "string":
				oObj = document.getElementById(vObj);
				break;
		}
		return oObj;
	};

	//	private: setup properties on first call to Apply
	function _Setup() {
		_bIE55 = (typeof(document.body.contentEditable) != "undefined");
		_bIE6 = (typeof(document.compatMode) != "undefined");

		if (!_bIE55) {
			if (document.styleSheets.length == 0)
				document.createStyleSheet();
			var oSheet = document.styleSheets[0];
			oSheet.addRule(".WCHhider", "visibility:visible");
			_oRule = oSheet.rules(oSheet.rules.length-1);
		}

		_bSetup = false;
	};
};
var WindowedControlsHider = new WCH_Constructor();

function getAllChildren(e) {
  // Returns all children of element. Workaround required for IE5/Windows. Ugh.
  return e.all ? e.all : e.getElementsByTagName('*');
}

document.getElementsBySelector = function(selector) {
  // Attempt to fail gracefully in lesser browsers
  if (!document.getElementsByTagName) {
    return new Array();
  }
  // Split selector in to tokens
  var tokens = selector.split(' ');
  var currentContext = new Array(document);
  for (var i = 0; i < tokens.length; i++) {
    token = tokens[i].replace(/^\s+/,'').replace(/\s+$/,'');;
    if (token.indexOf('#') > -1) {
      // Token is an ID selector
      var bits = token.split('#');
      var tagName = bits[0];
      var id = bits[1];
      var element = document.getElementById(id);
      if (tagName && element.nodeName.toLowerCase() != tagName) {
        // tag with that ID not found, return false
        return new Array();
      }
      // Set currentContext to contain just this element
      currentContext = new Array(element);
      continue; // Skip to next token
    }
    if (token.indexOf('.') > -1) {
      // Token contains a class selector
      var bits = token.split('.');
      var tagName = bits[0];
      var className = bits[1];
      if (!tagName) {
        tagName = '*';
      }
      // Get elements matching tag, filter them for class selector
      var found = new Array;
      var foundCount = 0;
      for (var h = 0; h < currentContext.length; h++) {
        var elements;
        if (tagName == '*') {
            elements = getAllChildren(currentContext[h]);
        } else {
            elements = currentContext[h].getElementsByTagName(tagName);
        }
        for (var j = 0; j < elements.length; j++) {
          found[foundCount++] = elements[j];
        }
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      for (var k = 0; k < found.length; k++) {
        if (found[k].className && found[k].className.match(new RegExp('\\b'+className+'\\b'))) {
          currentContext[currentContextIndex++] = found[k];
        }
      }
      continue; // Skip to next token
    }
    // Code to deal with attribute selectors
    if (token.match(/^(\w*)\[(\w+)([=~\|\^\$\*]?)=?"?([^\]"]*)"?\]$/)) {
      var tagName = RegExp.$1;
      var attrName = RegExp.$2;
      var attrOperator = RegExp.$3;
      var attrValue = RegExp.$4;
      if (!tagName) {
        tagName = '*';
      }
      // Grab all of the tagName elements within current context
      var found = new Array;
      var foundCount = 0;
      for (var h = 0; h < currentContext.length; h++) {
        var elements;
        if (tagName == '*') {
            elements = getAllChildren(currentContext[h]);
        } else {
            elements = currentContext[h].getElementsByTagName(tagName);
        }
        for (var j = 0; j < elements.length; j++) {
          found[foundCount++] = elements[j];
        }
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      var checkFunction; // This function will be used to filter the elements
      switch (attrOperator) {
        case '=': // Equality
          checkFunction = function(e) { return (e.getAttribute(attrName) == attrValue); };
          break;
        case '~': // Match one of space seperated words 
          checkFunction = function(e) { return (e.getAttribute(attrName).match(new RegExp('\\b'+attrValue+'\\b'))); };
          break;
        case '|': // Match start with value followed by optional hyphen
          checkFunction = function(e) { return (e.getAttribute(attrName).match(new RegExp('^'+attrValue+'-?'))); };
          break;
        case '^': // Match starts with value
          checkFunction = function(e) { return (e.getAttribute(attrName).indexOf(attrValue) == 0); };
          break;
        case '$': // Match ends with value - fails with "Warning" in Opera 7
          checkFunction = function(e) { return (e.getAttribute(attrName).lastIndexOf(attrValue) == e.getAttribute(attrName).length - attrValue.length); };
          break;
        case '*': // Match ends with value
          checkFunction = function(e) { return (e.getAttribute(attrName).indexOf(attrValue) > -1); };
          break;
        default :
          // Just test for existence of attribute
          checkFunction = function(e) { return e.getAttribute(attrName); };
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      for (var k = 0; k < found.length; k++) {
        if (checkFunction(found[k])) {
          currentContext[currentContextIndex++] = found[k];
        }
      }
      // alert('Attribute Selector: '+tagName+' '+attrName+' '+attrOperator+' '+attrValue);
      continue; // Skip to next token
    }
    // If we get here, token is JUST an element (not a class or ID selector)
    tagName = token;
    var found = new Array;
    var foundCount = 0;
    for (var h = 0; h < currentContext.length; h++) {
      var elements = currentContext[h].getElementsByTagName(tagName);
      for (var j = 0; j < elements.length; j++) {
        found[foundCount++] = elements[j];
      }
    }
    currentContext = found;
  }
  return currentContext;
}

Framework.DocumentFinder = function() {}

Framework.DocumentFinder.getElementsBySelector = function(css){return document.getElementsBySelector(css);}

function evSetFrameHeight (h) {
	var elements = Framework.DocumentFinder.getElementsBySelector('iframe');
	if (elements && elements.length > 0) {
		for (i = 0; i < elements.length; i++) {
			elements[i].height= h + 'px';
		}
	}
}


/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	ADxMenu.js - v4 (4.10)
	aplus.co.yu/adxmenu/
	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	(c) Copyright 2003, Aleksandar Vacic, www.aplus.co.yu
		This work is licensed under the Creative Commons Attribution License.
		To view a copy of this license, visit http://creativecommons.org/licenses/by/2.0/ or
		send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
Framework.ADxMenu = function() {}

Framework.ADxMenu.ieSetup = function() {
	var aTmp2, i, j, oLI, aUL, aA;
	var aTmp = this.getElementsByClassName("adxm", document, "ul");
	for (i=0;i<aTmp.length;i++) {
		aTmp2 = aTmp[i].getElementsByTagName("li");
		for (j=0;j<aTmp2.length;j++) {
			oLI = aTmp2[j];
			aUL = oLI.getElementsByTagName("ul");
			//	if item has submenu, then make the item hoverable
			if (aUL && aUL.length) {
				oLI.UL = aUL[0];	//	direct submenu
				aA = oLI.getElementsByTagName("a");
				if (aA && aA.length)
					oLI.A = aA[0];	//	direct child link
				//	li:hover
				oLI.onmouseenter = function() {
					this.className += " adxmhover";
					this.UL.className += " adxmhoverUL";
					if (this.A) this.A.className += " adxmhoverA";
					if (WindowedControlsHider) WindowedControlsHider.apply( this.UL, this, true );
				};
				//	li:blur
				oLI.onmouseleave = function() {
					this.className = this.className.replace(/adxmhover/gi,"");
					this.UL.className = this.UL.className.replace(/adxmhoverUL/gi,"");
					if (this.A) this.A.className = this.A.className.replace(/adxmhoverA/gi,"");
					if (WindowedControlsHider) WindowedControlsHider.discard( this.UL, this );
				};
			}
		}	//for-li.submenu
	}	//for-ul.adxm
}

/*	getElementsByClassName()
	Returns an array of elements which are
	descendants of parentEle and have tagName and clsName.
	If parentEle is null or not present, document will be used.
	if tagName is null or not present, "*" will be used.
	credits: Mike Foster, cross-browser.com.
*/	
Framework.ADxMenu.getElementsByClassName = function(clsName, parentEle, tagName) {
	var elements = null;
	var found = new Array();
	var re = new RegExp('\\b'+clsName+'\\b');
	if (!parentEle) parentEle = document;
	if (!tagName) tagName = '*';
	if (parentEle.getElementsByTagName) {elements = parentEle.getElementsByTagName(tagName);}
	else if (document.all) {elements = document.all.tags(tagName);}
	if (elements) {
		for (var i = 0; i < elements.length; ++i) {
			if (elements[i].className.search(re) != -1) {
				found[found.length] = elements[i];
			}
		}
	}
	return found;
}

/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	fix IE6/7 problem: on mouse over, force showing help over "?" icon (on forms)
	uses getElementsByClassName from ADxMenu (above)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
Framework.FormHelp = function() {
}

Framework.FormHelp.ieSetup = function() {
	if (!document.all || window.opera) return;
	var aTmp = Framework.ADxMenu.getElementsByClassName("formhelp", document, "a");
	if (aTmp && aTmp.length) {
		for (var i=0;i<aTmp.length;i++) {
			aTmp[i].onmouseenter = function() {
				if (!(x = this.getElementsByTagName('span')[0])) return;
				x.style.visibility = 'visible';
			};
			aTmp[i].onmouseleave = function() {
				if (!(x = this.getElementsByTagName('span')[0])) return;
				x.style.visibility = 'hidden';
			};
		}
	}
}

Framework.WindowNameManager = function() {
}

Framework.WindowNameManager.getWindowName = function WindowNameManager$getWindowName() {
	
	try{
	    return window.top.name;
	    }
	    catch(e){
	    return window.name;
	    }
}

Framework.WindowNameManager.setWindowName = function WindowNameManager$setWindowName(name) {
	window.top.name = name;
}

Framework.XMLHttpRequestDecorator = function() {
}
Framework.XMLHttpRequestDecorator.prototype = {
	_body : null,
	_request : null,
	_requestHeaders : {},
	onreadystatechange : null,
	readyState : 0,
	responseText : null,
	responseXML : null,
	status : null,
	statusText : null,
	abort : function() {
		this._request.abort();
	},
	getAllResponseHeaders : function() {
		return this._request.getAllResponseHeaders();
	},
	getResponseHeader : function(name) {
		return this._request.getResponseHeader(name);
	},
	open : function(method, url, async, username, password) {
		var that = this;
		this._request = new XMLHttpRequest();
		this._request.onreadystatechange = function() {
			that.readyState = that._request.readyState;
			if (that._request.readyState === 4) {
				that.responseText = that._request.responseText;
				that.responseXML = that._request.responseXML;
				that.status = that._request.status;
				that.statusText = that._request.statusText;
				if (!that._request.getResponseHeader('Date') && ((that._request.status >= 200  && that._request.status <= 299) || that._request.status === 304)) {
					var lastModified = that._request.getResponseHeader('Last-Modified');
					//that._request.onreadystatechange = null;
					that._request = new XMLHttpRequest();
					that._request.onreadystatechange = function() {
						that.readyState = that._request.readyState;
						if (that._request.readyState === 4) {
							if (that._request.status >= 200 && that._request.status <= 299) {
								that.responseText = that._request.responseText;
								that.responseXML = that._request.responseXML;
							}
							that.status = that._request.status;
							that.statusText = that._request.statusText;
						}
						that.onreadystatechange();
						if (that._request.readyState === 4) {
							that.onreadystatechange = null;
							that._request = null;
						}
					}
					that._request.open(method, url, async, username, password);
					that._request.setRequestHeader('If-Modified-Since', lastModified || 'Thu, 01 Jan 1970 00:00:00 GMT');
					if (that._requestHeaders)
						for (var headerName in that._requestHeaders)
							that._request.setRequestHeader(headerName, that._requestHeaders[headerName]);
					that._request.send(that._body);
				} else {
					that.onreadystatechange();
					that.onreadystatechange = null;
					that_request = null;
				}
			} else
				that.onreadystatechange();
		}
		this._request.open(method, url, async, username, password);
	},
	send : function(body) {
		this._body = body;
		this._request.send(body);
	},
	setRequestHeader : function(name, value) {
		this._request.setRequestHeader(name, value);
		this._requestHeaders[name] = value;
	}
}

///////////////////////////////////////////////////////////////////////////////
// Change Current and Neutral CultureInfo to UK format

CultureInfo.Neutral = new CultureInfo('en-UK',
    {
        naNSymbol: 'NaN',
        negativeSign: '-',
        positiveSign: '+',
        negativeInfinityText: '-Infinity',
        positiveInfinityText: 'Infinity',

        percentSymbol: '%',
        percentGroupSizes: [3],
        percentDecimalDigits: 2,
        percentDecimalSeparator: '.',
        percentGroupSeparator: ',',
        percentPositivePattern: '{0} %',
        percentNegativePattern: '-{0} %',

        currencySymbol: '£',
        currencyGroupSizes: [3],
        currencyDecimalDigits: 2,
        currencyDecimalSeparator: '.',
        currencyGroupSeparator: ',',
        currencyNegativePattern: '(${0})',
        currencyPositivePattern: '${0}',

        numberGroupSizes: [3],
        numberDecimalDigits: 2,
        numberDecimalSeparator: '.',
        numberGroupSeparator: ','
    },
    {
        amDesignator: 'AM',
        pmDesignator: 'PM',

        dateSeparator: '/',
        timeSeparator: ':',

        gmtDateTimePattern: 'ddd, dd MMM yyyy HH:mm:ss \'GMT\'',
        universalDateTimePattern: 'yyyy-MM-dd HH:mm:ssZ',
        sortableDateTimePattern: 'yyyy-MM-ddTHH:mm:ss',
        dateTimePattern: 'dddd, dd MMMM, yyyy h:mm:ss tt',

        longDatePattern: 'dddd, dd MMMM, yyyy',
        shortDatePattern: 'd/M/yyyy',

        longTimePattern: 'h:mm:ss tt',
        shortTimePattern: 'h:mm tt',

        firstDayOfWeek: 0,
        dayNames: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
        shortDayNames: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
        minimizedDayNames: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],

        monthNames: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December', ''],
        shortMonthNames: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', '']
    });
CultureInfo.Current = CultureInfo.Neutral;

Framework.ADxMenu.createClass('Framework.ADxMenu');
Framework.DocumentEvents.createClass('Framework.DocumentEvents');
Framework.DocumentBehaviors.createClass('Framework.DocumentBehaviors');
Framework.Behavior.ParametersObjectBuilder.createClass('Framework.Behavior.ParametersObjectBuilder');
Framework.Util.DebugInfoProvider.createClass('Framework.Util.DebugInfoProvider');
Framework.DocumentFinder.createClass('Framework.DocumentFinder');
Framework.FormHelp.createClass('Framework.FormHelp');
Framework.JsonUtil.createClass('Framework.JsonUtil');
//Framework.WindowedControlsHider.createClass('Framework.WindowedControlsHider');
//Framework.WindowInstanceExt.createClass('Framework.WindowInstanceExt');
Framework.WindowNameManager.createClass('Framework.WindowNameManager');
Framework.XMLUtils.createClass('Framework.XMLUtils');
Framework.XMLHttpRequestDecorator.createClass('Framework.XMLHttpRequestDecorator');

Framework.ScriptSharpQuirks = function() {
}

Framework.ScriptSharpQuirks.isNumberNull = function ScriptSharpQuirks$isNumberNull(number) {
	return number == null;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ITopicChangedListener

Framework.ITopicChangedListener = function() { };
Framework.ITopicChangedListener.prototype = {
    onTopicChanged : null
}
Framework.ITopicChangedListener.createInterface('Framework.ITopicChangedListener');


////////////////////////////////////////////////////////////////////////////////
// Framework.IRpcTask

Framework.IRpcTask = function() { };
Framework.IRpcTask.prototype = {
    getRequestPayload : null,
    processResponse : null
}
Framework.IRpcTask.createInterface('Framework.IRpcTask');


////////////////////////////////////////////////////////////////////////////////
// Framework.IEnvironment

Framework.IEnvironment = function() { };
Framework.IEnvironment.prototype = {
    init : null,
    start : null,
    registerPageWillChangeListener : null,
    get_componentUpdateScheduler : null,
    getProtocol : null,
    getLanguage : null,
    getRegion : null,
    getPageArea : null,
    getInitialPageFilter : null,
    getDomElement : null,
    updateDomElement : null,
    updateDomElementDirect : null,
    transformAndUpdate : null,
    periodicalTransformAndUpdate : null,
    periodicalTransformAndUpdateWithContentUrlDelegate : null,
    clearPeriodicalTransformAndUpdate : null,
    invoke : null,
	invokeAsyncSingle : null,
    invokeAsync : null,
    invokeAsyncUsingJsonp : null,
    storeState : null,
    getStoredState : null,
    get_debugInfo : null,
    getCookie : null,
    setCookie : null,
    setCookieWithDays : null,
    clearCookie : null,
    clearCookies : null,
    getBaselineUrl : null,
    changeLocation : null,
    changeRegion : null,
    changeLanguage : null,
    buildUrl : null,
    getHash : null,
    setHash : null,
    safelySetCssClass : null,
    safelyRemoveCssClass : null,
    safelySetAndUnsetCssClass : null,
    safelySetAndUnsetCssClassIf : null,
    containsCssClass : null,
    safelySetCssClassOnElement : null,
    safelyRemoveCssClassOnElement : null,
    safelySetAndUnsetCssClassOnElement : null,
    safelySetAndUnsetCssClassOnElementIf : null,
    containsCssClassOnElement : null
}
Framework.IEnvironment.createInterface('Framework.IEnvironment');


////////////////////////////////////////////////////////////////////////////////
// Framework.IPageWillChangeListener

Framework.IPageWillChangeListener = function() { };
Framework.IPageWillChangeListener.prototype = {
    onPageWillChange : null
}
Framework.IPageWillChangeListener.createInterface('Framework.IPageWillChangeListener');


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractComponent

Framework.AbstractComponent = function Framework_AbstractComponent() {
    this._log = Framework.Logger.getLog('AbstractComponent');
    this._children = new Array(0);
    this._componentLifeCycleManager = this.createComponentLifeCycleManager();
}
Framework.AbstractComponent.setFormEnabled = function Framework_AbstractComponent$setFormEnabled(domElementId, enabled) {
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('select'), enabled);
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('input'), enabled);
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('button'), enabled);
    Framework.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('textarea'), enabled);
}
Framework.AbstractComponent._setCollectionEnabled = function Framework_AbstractComponent$_setCollectionEnabled(domElementCollection, enabled) {
    for (var i = 0; i < domElementCollection.length; i++) {
        domElementCollection[i].disabled = !enabled;
    }
}
Framework.AbstractComponent.prototype = {
    _environment: null,
    _componentInstanceName: null,
    _domElementId: null,
    _currentArea: 0,
    _area: null,
    _adminHtmlUrl: null,
    _cssClass: null,
    _childID: null,
    _parent: null,
    _siblingIndex: 0,
    _componentLifeCycleManager: null,
    
    get_componentLifeCycleManager: function Framework_AbstractComponent$get_componentLifeCycleManager() {
        return this._componentLifeCycleManager;
    },
    
    _visibleNavigationTypes: null,
    
    get_visibleNavigationTypes: function Framework_AbstractComponent$get_visibleNavigationTypes() {
        return this._visibleNavigationTypes;
    },
    
    get_cssClass: function Framework_AbstractComponent$get_cssClass() {
        return this._cssClass;
    },
    
    childrenUpdateComplete: function Framework_AbstractComponent$childrenUpdateComplete(eventArgs) {
    },
    
    childComponentUpdateComplete: function Framework_AbstractComponent$childComponentUpdateComplete(eventArgs) {
    },
    
    get__abstractEnvironment: function Framework_AbstractComponent$get__abstractEnvironment() {
        return this._environment;
    },
    
    update: function Framework_AbstractComponent$update(domElement, contentID, xsltUrl, xsltParameters, afterTransformationCallback, inMemoryTransformationCallback, xmlContent) {
        if (!afterTransformationCallback && !inMemoryTransformationCallback) {
            this.get__abstractEnvironment().transformAndUpdate(domElement.id, contentID, xsltUrl, xsltParameters, Delegate.create(this, this.repaintComplete), domElement, Delegate.create(this, this.transformationComplete), xmlContent);
        }
        else {
            this.get__abstractEnvironment().transformAndUpdate(domElement.id, contentID, xsltUrl, xsltParameters, afterTransformationCallback, domElement, inMemoryTransformationCallback, xmlContent);
        }
    },
    
    periodicalUpdate: function Framework_AbstractComponent$periodicalUpdate(domElementId, contentID, xsltUrl, xsltParameters, domain, autoRefreshPeriod, afterTransformationCallback, inMemoryTransformationCallback) {
        if (!afterTransformationCallback && !inMemoryTransformationCallback) {
            this.get__abstractEnvironment().periodicalTransformAndUpdate(domElementId, contentID, xsltUrl, xsltParameters, Delegate.create(this, this.repaintComplete), domain, autoRefreshPeriod, Delegate.create(this, this.transformationComplete));
        }
        else {
            this.get__abstractEnvironment().periodicalTransformAndUpdate(domElementId, contentID, xsltUrl, xsltParameters, afterTransformationCallback, domain, autoRefreshPeriod, inMemoryTransformationCallback);
        }
    },
    
    transformationComplete: function Framework_AbstractComponent$transformationComplete(inMemoryComponent) {
        Framework.Behavior.Binding.BehaviorBinder.autoBind(inMemoryComponent, (this));
    },
    
    repaintComplete: function Framework_AbstractComponent$repaintComplete() {
    },
    
    createComponentLifeCycleManager: function Framework_AbstractComponent$createComponentLifeCycleManager() {
        var tmpObject = this;
        return new Framework.Component.LifeCycleManagement.ComponentLifeCycleManager(tmpObject);
    },
    
    get_componentInstanceName: function Framework_AbstractComponent$get_componentInstanceName() {
        return this._componentInstanceName;
    },
    
    get_domElementId: function Framework_AbstractComponent$get_domElementId() {
        return this._domElementId;
    },
    set_domElementId: function Framework_AbstractComponent$set_domElementId(value) {
        this._domElementId = value;
        return value;
    },
    
    init: function Framework_AbstractComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._log = Framework.Logger.getLog(domElementId);
        this._log.debug('Init');
        this._environment = environment;
        this._componentInstanceName = componentInstanceName;
        this._domElementId = domElementId;
        this._adminHtmlUrl = parameters['admin-html-url'];
        this._cssClass = parameters['css-class'];
        if (!String.isNullOrEmpty(parameters['visible-navigation-types'])) {
            this._visibleNavigationTypes = ScriptFX.JSON.deserialize((parameters['visible-navigation-types']));
        }
    },
    
    isNavigationTypesInAValidCombination: function Framework_AbstractComponent$isNavigationTypesInAValidCombination(currentNavTypes) {
        var navtypesToCheck = this.get_visibleNavigationTypes();
        if (!currentNavTypes) {
            return true;
        }
        if (!navtypesToCheck) {
            return true;
        }
        for (var count = 0; count < navtypesToCheck.length; count++) {
            if (navtypesToCheck[count].isMatch(currentNavTypes)) {
                return true;
            }
        }
        return false;
    },
    
    start: function Framework_AbstractComponent$start() {
        this._log.debug('Start');
        this.repaint();
    },
    
    repaintForAdmin: function Framework_AbstractComponent$repaintForAdmin() {
        var ajaxUpdater = new Framework.AjaxUpdater(this._domElementId, this._adminHtmlUrl, null, Delegate.create(this, function() {
            this._environment.updateDomElement(this._domElementId, this._domElementId);
        }));
        ajaxUpdater.update();
    },
    
    disableForAdmin: function Framework_AbstractComponent$disableForAdmin() {
        var anchors = this._environment.getDomElement(this._domElementId).getElementsByTagName('A');
        for (var i = 0; i < anchors.length; i++) {
            var anchor = anchors[i];
            anchor.setAttribute('href', '#');
            anchor.setAttribute('onclick', 'return false;');
        }
    },
    
    isVisible: function Framework_AbstractComponent$isVisible(visibleOn, notVisibleOn, action) {
        if (!visibleOn.length && !notVisibleOn.length) {
            return true;
        }
        if (visibleOn.length > 0) {
            return visibleOn.contains(action);
        }
        if (notVisibleOn.length > 0) {
            return !notVisibleOn.contains(action);
        }
        throw new Error('Parameters were not specified correctly.');
    },
    
    show: function Framework_AbstractComponent$show() {
        if (!this.get_domElementId()) {
            return;
        }
        if (!this._environment.getDomElement(this.get_domElementId())) {
            return;
        }
        this._environment.getDomElement(this.get_domElementId()).style.display = 'block';
    },
    
    hide: function Framework_AbstractComponent$hide() {
        if (!this.get_domElementId()) {
            return;
        }
        if (!this._environment.getDomElement(this.get_domElementId())) {
            return;
        }
        this._environment.getDomElement(this.get_domElementId()).style.display = 'none';
        this._environment.updateDomElement(this.get_domElementId(), String.Empty);
    },
    
    disable: function Framework_AbstractComponent$disable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'wait';
        Framework.AbstractComponent.setFormEnabled(this._domElementId, false);
    },
    
    enable: function Framework_AbstractComponent$enable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'default';
        Framework.AbstractComponent.setFormEnabled(this._domElementId, true);
    },
    
    getPrivateDomElement: function Framework_AbstractComponent$getPrivateDomElement(domElementNameSuffix) {
        return document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
    },
    
    updatePrivateDomElement: function Framework_AbstractComponent$updatePrivateDomElement(domElementNameSuffix, htmlContent) {
        this.updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, null, null);
    },
    
    updatePrivateDomElementWithCallback: function Framework_AbstractComponent$updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, successCallback, failureCallback) {
        try {
            var element = document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
            if (element) {
                this._environment.updateDomElementDirect(element, htmlContent);
                if (successCallback) {
                    successCallback.invoke();
                }
            }
            else {
                throw new Error(String.format('domElementNameSuffix [{0}] cannot be found!', domElementNameSuffix));
            }
        }
        catch (ex) {
            this._log.error('UpdatePrivateDomElement', ex);
            if (failureCallback) {
                failureCallback.invoke(ex);
            }
        }
    },
    
    activateArea: function Framework_AbstractComponent$activateArea(area, messages) {
        this._log.debug(String.format('ActivateArea area=[{0}] messages=[{1}]', area, messages));
        this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea]).style.display = 'none';
        this._currentArea = area;
        this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea]).style.display = 'block';
        if (messages) {
            for (var i = 0; i < messages.length; i++) {
                if (!String.isNullOrEmpty(messages[i])) {
                    this._environment.getDomElement(this._domElementId + '-' + this._area[this._currentArea] + '-' + i).innerText = messages[i];
                }
            }
        }
    },
    
    getTranslation: function Framework_AbstractComponent$getTranslation(phrase) {
        return this.getPrivateDomElement(phrase).innerHTML;
    },
    
    get_parent: function Framework_AbstractComponent$get_parent() {
        return this._parent;
    },
    
    get_childID: function Framework_AbstractComponent$get_childID() {
        return this._childID;
    },
    set_childID: function Framework_AbstractComponent$set_childID(value) {
        this._childID = value;
        return value;
    },
    
    startChildren: function Framework_AbstractComponent$startChildren() {
        for (var index = 0; index < this._children.length; index++) {
            var newComponent = (this._children[index]);
            if (!isNullOrUndefined(newComponent.get_componentLifeCycleManager())) {
                newComponent.get_componentLifeCycleManager().start();
            }
            else {
                this._children[index].start();
            }
        }
    },
    
    addChild: function Framework_AbstractComponent$addChild(child) {
        var index = this._children.length;
        this._children[index] = child;
        child._parent = this;
        child._siblingIndex = index;
    },
    
    get_hasChildren: function Framework_AbstractComponent$get_hasChildren() {
        if (!this._children) {
            return false;
        }
        return this._children.length > 0;
    },
    
    get_children: function Framework_AbstractComponent$get_children() {
        return this._children;
    },
    
    getChildByID: function Framework_AbstractComponent$getChildByID(childID) {
        for (var count = 0; count < this._children.length; count++) {
            if (this._children[count].get_childID() === childID) {
                return this._children[count];
            }
        }
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractEnvironment

Framework.AbstractEnvironment = function Framework_AbstractEnvironment(components, dynamicComponentsConfiguration, services) {
    this._multiplexedRpcTasks = [];
    this._pageWillChangeListeners = [];
    this._transformAndUpdateQueue = [];
    Framework.AbstractEnvironment._log.debug('Creating AbstractEnvironment');
    this.components = components;
    this.dynamicComponentsConfiguration = dynamicComponentsConfiguration;
    this.services = services;
    this._componentUpdateScheduler = new Framework.Component.Updating.ComponentUpdateScheduler();
}
Framework.AbstractEnvironment.getInstance = function Framework_AbstractEnvironment$getInstance() {
    return Framework.AbstractEnvironment._singeltonAbstractEnvironment;
}
Framework.AbstractEnvironment.createInstance = function Framework_AbstractEnvironment$createInstance(components, dynamicComponents, services) {
    Framework.AbstractEnvironment._singeltonAbstractEnvironment = new Framework.AbstractEnvironment(components, dynamicComponents, services);
    return Framework.AbstractEnvironment.getInstance();
}
Framework.AbstractEnvironment.safeUpdateDomElement = function Framework_AbstractEnvironment$safeUpdateDomElement(domElementId, htmlContent) {
    var domElement = document.getElementById(domElementId);
    if (domElement) {
        Framework.AbstractEnvironment.safeUpdateDomElementDirect(domElement, htmlContent);
    }
    else {
        Framework.AbstractEnvironment._log.debug(String.format('Environment.UpdateDomElement Error - Dom element id [{0}] does not exist', domElementId));
    }
}
Framework.AbstractEnvironment.safeUpdateDomElementDirect = function Framework_AbstractEnvironment$safeUpdateDomElementDirect(domElement, htmlContent) {
    if (!domElement) {
        return;
    }
    if (domElement.innerHTML === htmlContent) {
        Framework.AbstractEnvironment._log.debug(domElement.id + '.InnerHTML unchanged - not updated');
    }
    else {
        Framework.DocumentEvents.purgeEventsBeforeUpdate(domElement, true, 0);
        domElement.innerHTML = htmlContent;
    }
}
Framework.AbstractEnvironment.serializeToXml = function Framework_AbstractEnvironment$serializeToXml(instanceName, value, isKeyValue) {
    if ((!instanceName) || (!instanceName)) {
        return String.Empty;
    }
    var isArray = false;
    isArray = (value instanceof Array);;
    var type = '';
    type = (typeof value);;
    var isValue = (type === 'boolean') || (type === 'number') || (type === 'string');
    var isObject = (type === 'object');
    var isInstanceNameNumeric = false;
    isInstanceNameNumeric =  !isNaN(instanceName);
    var attributes = '';
    if (isKeyValue) {
        attributes = ' key=\"' + instanceName + '\"';
        instanceName = 'value';
    }
    if (isArray || isObject) {
        return String.format('<{0}{2}>{1}</{0}>', instanceName, Framework.AbstractEnvironment.serializeDictionaryToXml(value, isArray), attributes);
    }
    else if (isValue) {
        return String.format('<{0}>{1}</{0}>', instanceName, value);
    }
    return String.Empty;
}
Framework.AbstractEnvironment.serializeDictionaryToXml = function Framework_AbstractEnvironment$serializeDictionaryToXml(dictionary, isArray) {
    if (!dictionary) {
        return String.Empty;
    }
    var result = '';
    if (Object.getKeyCount(dictionary) > 0) {
        var $dict1 = dictionary;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (entry.key) {
                result += Framework.AbstractEnvironment.serializeToXml(entry.key, entry.value, isArray);
            }
        }
    }
    return result;
}
Framework.AbstractEnvironment.prototype = {
    _componentUpdateScheduler: null,
    components: null,
    dynamicComponentsConfiguration: null,
    services: null,
    _state: null,
    _language: null,
    _region: null,
    _pageArea: null,
    _initialPageFilter: null,
    
    getProtocol: function Framework_AbstractEnvironment$getProtocol() {
        return window.location.protocol.split(':')[0];
    },
    
    getLanguage: function Framework_AbstractEnvironment$getLanguage() {
        return this._language;
    },
    
    getRegion: function Framework_AbstractEnvironment$getRegion() {
        return this._region;
    },
    
    getPageArea: function Framework_AbstractEnvironment$getPageArea() {
        return this._pageArea;
    },
    
    getInitialPageFilter: function Framework_AbstractEnvironment$getInitialPageFilter() {
        return this._initialPageFilter;
    },
    
    get_componentUpdateScheduler: function Framework_AbstractEnvironment$get_componentUpdateScheduler() {
        return this._componentUpdateScheduler;
    },
    
    init: function Framework_AbstractEnvironment$init(language, region, pageArea, pageFilter) {
        Framework.AbstractEnvironment._log.debug('Init');
        this._language = language;
        this._region = region;
        this._pageArea = pageArea;
        this._initialPageFilter = pageFilter;
        Framework.SDC.SDCManager.initializeSDCManager();
        if (!String.isNullOrEmpty(Framework.CustomCultureInfo.getRegionalCultureKey(this._region, this._language))) {
            this._setCurrentCulture(Framework.CustomCultureInfo.getRegionalCultureKey(this._region, this._language));
        }
        var windowNameStateKey = '_window.top.name';
        var windowNameCurrentDomainKey = '_windowNameCurrentDomain';
        var debugInfoKey = '_debugInfo';
        var stateString = Framework.WindowNameManager.getWindowName();
        if (!isNullOrUndefined(stateString) && !String.isNullOrEmpty(stateString)) {
            try {
                var state = Framework.JsonUtil.deserialize(Framework.WindowNameManager.getWindowName());
                if (state && Type.getInstanceType(state) === Object) {
                    if (Object.keyExists((state), windowNameCurrentDomainKey) && (state)[windowNameCurrentDomainKey].toString() === window.location.hostname) {
                        this._state = state;
                        Framework.WindowNameManager.setWindowName(this._state[windowNameStateKey]);
                        if (!String.isNullOrEmpty(this._state[debugInfoKey])) {
                            this._debugInfo = this._state[debugInfoKey];
                        }
                    }
                    else {
                        this._state = {};
                        Framework.WindowNameManager.setWindowName('');
                    }
                }
                else {
                    this._state = {};
                }
            }
            catch ($e1) {
                this._state = {};
            }
        }
        else {
            this._state = {};
        }
        window.attachEvent('onbeforeunload', Delegate.create(this, function() {
            this.firePageWillChangeEvent();
            this._state[windowNameStateKey] = Framework.WindowNameManager.getWindowName();
            this._state[windowNameCurrentDomainKey] = window.location.hostname;
            this._state[debugInfoKey] = this._debugInfo;
            Framework.WindowNameManager.setWindowName(Framework.JsonUtil.serialize(this._state));
        }));
    },
    
    start: function Framework_AbstractEnvironment$start() {
        Framework.AbstractEnvironment._log.debug('Start');
        this._transformAndUpdateScheduler(0);
        this.get_componentUpdateScheduler().runSchedulingRuntime(500);
        if (String.isNullOrEmpty(this._debugInfo)) {
            this._fetchDebugInfo();
        }
    },
    
    registerPageWillChangeListener: function Framework_AbstractEnvironment$registerPageWillChangeListener(pageWillChangeListener) {
        if (!this._pageWillChangeListeners.contains(pageWillChangeListener)) {
            this._pageWillChangeListeners.add(pageWillChangeListener);
        }
    },
    
    firePageWillChangeEvent: function Framework_AbstractEnvironment$firePageWillChangeEvent() {
        var $enum1 = this._pageWillChangeListeners.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            listener.onPageWillChange();
        }
    },
    
    createRealUrl: function Framework_AbstractEnvironment$createRealUrl(url) {
        return ((!url) ? null : url.replace('${region}', this._region).replace('${language}', this._language));
    },
    
    getDomElement: function Framework_AbstractEnvironment$getDomElement(domElementId) {
        return document.getElementById(domElementId);
    },
    
    updateDomElement: function Framework_AbstractEnvironment$updateDomElement(domElementId, htmlContent) {
        var domElement = document.getElementById(domElementId);
        if (domElement) {
            Framework.AbstractEnvironment.safeUpdateDomElementDirect(domElement, htmlContent);
        }
        else {
            Framework.AbstractEnvironment._log.debug(String.format('Environment.UpdateDomElement Error - Dom element id [{0}] does not exist', domElementId));
        }
    },
    
    updateDomElementDirect: function Framework_AbstractEnvironment$updateDomElementDirect(domElement, htmlContent) {
        Framework.AbstractEnvironment.safeUpdateDomElementDirect(domElement, htmlContent);
    },
    
    transformAndUpdateInner: function Framework_AbstractEnvironment$transformAndUpdateInner(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domain, autoRefreshPeriod, domElement, inMemoryProcessingCallback, xmlContent, contentUrlDelegate, useContentUrlDelegate) {
        var placeHolder = (!domElement) ? document.getElementById(domElementId) : domElement;
        if (placeHolder) {
            this.updateDomElementDirect(placeHolder, '<img src=\'/indicator.gif\' />');
            var transformAndUpdateTask = new Framework.TransformAndUpdateTask(domElementId, this.createRealUrl(contentId), xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domain, autoRefreshPeriod, this, domElement, inMemoryProcessingCallback, (xmlContent) ? XMLDocumentParser.parse(xmlContent) : Framework.XMLUtils.get_emptyContentDocument(), (xmlContent) ? true : false, contentUrlDelegate, useContentUrlDelegate);
            transformAndUpdateTask.execute(true);
            return transformAndUpdateTask;
        }
        return null;
    },
    
    transformAndUpdate: function Framework_AbstractEnvironment$transformAndUpdate(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domElement, inMemoryProcessingCallback, xmlContent) {
        Framework.AbstractEnvironment._log.debug(String.format('TransformAndUpdate domElementId=[{0}] contentId=[{1}] xsltUrl=[{2}] xsltParameters=[{3}]', domElementId, contentId, xsltUrl, Framework.DictionaryUtil.dumpToString(xsltParameters)));
        this.transformAndUpdateInner(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, null, null, domElement, inMemoryProcessingCallback, xmlContent);
    },
    
    periodicalTransformAndUpdate: function Framework_AbstractEnvironment$periodicalTransformAndUpdate(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod, inMemoryProcessingCallback, contentIdDelegate, useContentIdDelegate) {
        Framework.AbstractEnvironment._log.debug(String.format('ScheduledTransformAndUpdate domElementId=[{0}] contentId=[{1}] xsltUrl=[{2}] xsltParameters=[{3}] domain=[{4}] autoRefreshPeriod=[{5}]', domElementId, contentId, xsltUrl, Framework.DictionaryUtil.dumpToString(xsltParameters), domain, autoRefreshPeriod));
        var task = this.transformAndUpdateInner(domElementId, contentId, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod, null, inMemoryProcessingCallback, null, contentIdDelegate, useContentIdDelegate);
        if (task) {
            this._transformAndUpdateQueue.add(task);
        }
    },
    
    periodicalTransformAndUpdateWithContentUrlDelegate: function Framework_AbstractEnvironment$periodicalTransformAndUpdateWithContentUrlDelegate(domElementId, contentUrlDelegate, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod) {
        this.periodicalTransformAndUpdate(domElementId, null, xsltUrl, xsltParameters, afterTransformAndUpdateCallbac, domain, autoRefreshPeriod, null, contentUrlDelegate, true);
    },
    
    clearPeriodicalTransformAndUpdate: function Framework_AbstractEnvironment$clearPeriodicalTransformAndUpdate(domain) {
        Framework.AbstractEnvironment._log.debug(String.format('ClearScheduledTransformAndUpdate domain=[{0}]', domain));
        var newQueue = [];
        for (var i = 0; i < this._transformAndUpdateQueue.length; i++) {
            if (domain !== (this._transformAndUpdateQueue[i]).get_domain()) {
                newQueue.add(this._transformAndUpdateQueue[i]);
            }
        }
        this._transformAndUpdateQueue = newQueue;
    },
    
    _transformAndUpdateScheduler: function Framework_AbstractEnvironment$_transformAndUpdateScheduler(startIndex) {
        var queue = this._transformAndUpdateQueue;
        Framework.AbstractEnvironment._log.debug(String.format('TransformAndUpdateScheduler woke up!, StartIndex=[{0}]', startIndex));
        if (queue && queue.length > 0) {
            startIndex = Math.min(startIndex, queue.length - 1);
            var i = startIndex;
            do {
                var currentTask = queue[i];
                Framework.AbstractEnvironment._log.debug(String.format('TransformAndUpdateScheduler processing task i=[{0}] LastExecuted=[{1}] AutoRefreshPeriod=[{2}]', i, currentTask.get_lastExecuted(), currentTask.get_autoRefreshPeriod()));
                i = (i + 1) % queue.length;
                if (currentTask.get_lastExecuted().getTime() + currentTask.get_autoRefreshPeriod() < Date.get_now().getTime()) {
                    currentTask.execute(true);
                    break;
                }
            } while (i !== startIndex);
            startIndex = i;
        }
        window.setTimeout(Delegate.create(this, function() {
            this._transformAndUpdateScheduler(startIndex);
        }), Framework.Parameters.transformAndUpdateSchedulerPeriod);
    },
    
    _getCallBrokerUrl: function Framework_AbstractEnvironment$_getCallBrokerUrl() {
        return '/CallBroker.ashx';
    },
    
    invoke: function Framework_AbstractEnvironment$invoke(serviceName, methodName, arguments) {
        Framework.AbstractEnvironment._log.debug('invoke serviceName = [' + serviceName + '] methodName = [' + methodName + '] arguments = [...]');
        var request = new XMLHttpRequest();
        request.open('POST', this._getCallBrokerUrl(), false);
        request.setRequestHeader('Content-Type', 'text/json');
        var requestPayload = {};
        requestPayload['serviceName'] = serviceName;
        requestPayload['methodName'] = methodName;
        requestPayload['arguments'] = arguments;
        var JSONrequestPayload = Framework.JsonUtil.serialize(requestPayload);
        request.send(JSONrequestPayload);
        var status = request.status;
        Framework.AbstractEnvironment._log.debug(String.format('Status = [{0}]', status));
        if (status === 200) {
            var response = Framework.JsonUtil.deserialize(request.responseText);
            return response['result'];
        }
        else if (status === 500) {
            try {
                var response = Framework.JsonUtil.deserialize(request.responseText);
                throw Framework.ExceptionUtil.createException(response['exceptionType'], response['message']);
            }
            catch (e) {
                Framework.AbstractEnvironment._log.error('Invoke failed', e);
                throw Framework.ExceptionUtil.createException('RemoteException', null);
            }
        }
        else {
            throw Framework.ExceptionUtil.createException('RemoteException', null);
        }
    },
    
    invokeAsyncSingle: function Framework_AbstractEnvironment$invokeAsyncSingle(serviceName, methodName, arguments, successCallback, failureCallback) {
        this._doInvokeAsync(serviceName, methodName, arguments, successCallback, failureCallback, true);
    },
    
    invokeAsync: function Framework_AbstractEnvironment$invokeAsync(serviceName, methodName, arguments, successCallback, failureCallback) {
        this._doInvokeAsync(serviceName, methodName, arguments, successCallback, failureCallback, false);
    },
    
    _doInvokeAsync: function Framework_AbstractEnvironment$_doInvokeAsync(serviceName, methodName, arguments, successCallback, failureCallback, forceSingleCall) {
        var rpcTask = new Framework.JsonRpcTask(serviceName, methodName, this.getLanguage(), arguments, successCallback, failureCallback);
        if (!forceSingleCall && Framework.AbstractEnvironment._enableMultiplexing) {
            if (!this._multiplexedRpcTasks.length) {
                window.setTimeout(Delegate.create(this, function() {
                    var multiplexPayload = [];
                    var $enum1 = this._multiplexedRpcTasks.getEnumerator();
                    while ($enum1.moveNext()) {
                        var task = $enum1.get_current();
                        multiplexPayload.add(task.getPayloadAsDictionary());
                    }
                    var httpRequest = ScriptFX.Net.HTTPRequest.createRequest(this._getCallBrokerUrl(), ScriptFX.Net.HTTPVerb.POST);
                    httpRequest.set_content(Framework.JsonUtil.serialize(multiplexPayload));
                    httpRequest.invoke(Delegate.create(this, function(request, context) {
                        var endTime = Date.get_now().getTime();
                        var multiplexedRpcTasks = context;
                        if (request.get_state() === ScriptFX.Net.HTTPRequestState.completed) {
                            if (request.get_response().get_statusCode() === ScriptFX.Net.HTTPStatusCode.OK) {
                                var multiplexResponses = Framework.JsonUtil.deserialize(request.get_response().getText());
                                for (var i = 0; i < multiplexResponses.length; i++) {
                                    this._invokeSingleRpcCallback(multiplexedRpcTasks[i], multiplexResponses[i], false, Framework.SDC.SDCExceptionType.noException, endTime);
                                }
                            }
                            else {
                                var remoteExceptionResponse = { exceptionType: 'RemoteException' };
                                for (var i = 0; i < multiplexedRpcTasks.length; i++) {
                                    this._invokeSingleRpcCallback(multiplexedRpcTasks[i], remoteExceptionResponse, false, Framework.SDC.SDCExceptionType.operationalException, endTime);
                                }
                            }
                        }
                        else {
                            var remoteExceptionResponse = { exceptionType: 'RemoteException' };
                            for (var i = 0; i < multiplexedRpcTasks.length; i++) {
                                var sdcException = Framework.SDC.SDCExceptionType.noException;
                                var abortSDCLog = true;
                                if (request.get_state() === ScriptFX.Net.HTTPRequestState.timedOut) {
                                    abortSDCLog = false;
                                    sdcException = Framework.SDC.SDCExceptionType.infrastructuralException;
                                }
                                this._invokeSingleRpcCallback(multiplexedRpcTasks[i], remoteExceptionResponse, abortSDCLog, sdcException, endTime);
                            }
                        }
                    }), this._multiplexedRpcTasks);
                    this._multiplexedRpcTasks = [];
                }), 0);
            }
            this._multiplexedRpcTasks.add(rpcTask);
        }
        else {
            var httpRequest = ScriptFX.Net.HTTPRequest.createRequest(this._getCallBrokerUrl(), ScriptFX.Net.HTTPVerb.POST);
            httpRequest.set_content(rpcTask.getRequestPayload());
            httpRequest.invoke(Delegate.create(this, function(request, context) {
                if (request.get_state() === ScriptFX.Net.HTTPRequestState.completed) {
                    (context).processResponse(request.get_response());
                }
                else {
                    if (request.get_state() === ScriptFX.Net.HTTPRequestState.timedOut) {
                        Framework.SDC.SDCManager.sdcManagerInstance().endRPCLog((context).getSDCToken(), '', Framework.SDC.SDCExceptionType.infrastructuralException);
                    }
                    else {
                        Framework.SDC.SDCManager.sdcManagerInstance().abortRPCLog((context).getSDCToken());
                    }
                    failureCallback.invoke(Framework.ExceptionUtil.createException('RemoteException', null));
                }
            }), rpcTask);
        }
    },
    
    _invokeSingleRpcCallback: function Framework_AbstractEnvironment$_invokeSingleRpcCallback(jsonRpcTask, singleResponse, abortSDCLog, sdcException, endTime) {
        var exceptionType = singleResponse['exceptionType'];
        var sdcExceptionType = (sdcException === Framework.SDC.SDCExceptionType.noException && !String.isNullOrEmpty(exceptionType)) ? Framework.SDC.SDCExceptionType.callbrokerRPCException : sdcException;
        var serverToken = singleResponse['token'] || '';
        if (!abortSDCLog) {
            Framework.SDC.SDCManager.sdcManagerInstance().endMultiplexRPCLog(jsonRpcTask.getSDCToken(), serverToken, sdcExceptionType, endTime);
        }
        else {
            Framework.SDC.SDCManager.sdcManagerInstance().abortRPCLog(jsonRpcTask.getSDCToken());
        }
        window.setTimeout(Delegate.create(this, function() {
            if (String.isNullOrEmpty(exceptionType)) {
                jsonRpcTask.get_jsonRpcSuccessCallback().invoke(singleResponse['result']);
            }
            else {
                jsonRpcTask.get_jsonRpcFailureCallback().invoke(Framework.ExceptionUtil.createException(exceptionType, singleResponse['message']));
            }
        }), 0);
    },
    
    invokeAsyncUsingJsonp: function Framework_AbstractEnvironment$invokeAsyncUsingJsonp(serviceName, methodName, arguments, successCallback, failureCallback, isHttpsForced) {
        var rpcTask = new Framework.JsonRpcTask(serviceName, methodName, this.getLanguage(), arguments, successCallback, failureCallback);
        var callBrokerUrl = (isHttpsForced && String.compare(window.location.protocol, 'https:')) ? 'https://' + window.location.hostname + '/CallBroker.ashx' : '/CallBroker.ashx';
        var httpRequest = ScriptFX.Net.HTTPRequest.createRequest(ScriptFX.Net.HTTPTransport.createURI(callBrokerUrl + '?payload=' + rpcTask.getRequestPayload(), ScriptFX.Net.ScriptTransport, null), ScriptFX.Net.HTTPVerb.GET);
        httpRequest.set_timeout(Framework.AbstractEnvironment._jsonpRequestTimeout);
        httpRequest.invoke(Delegate.create(this, function(request, context) {
            if (request.get_state() === ScriptFX.Net.HTTPRequestState.completed) {
                (context).processResponse(request.get_response());
            }
            else {
                if (request.get_state() === ScriptFX.Net.HTTPRequestState.timedOut) {
                    Framework.SDC.SDCManager.sdcManagerInstance().endRPCLog((context).getSDCToken(), '', Framework.SDC.SDCExceptionType.infrastructuralException);
                }
                else {
                    Framework.SDC.SDCManager.sdcManagerInstance().abortRPCLog((context).getSDCToken());
                }
                failureCallback.invoke(Framework.ExceptionUtil.createException('RemoteException', null));
            }
        }), rpcTask);
    },
    
    storeState: function Framework_AbstractEnvironment$storeState(serviceName, state) {
        this._state[serviceName] = state;
    },
    
    getStoredState: function Framework_AbstractEnvironment$getStoredState(serviceName) {
        return this._state[serviceName];
    },
    
    _debugInfo: null,
    
    get_debugInfo: function Framework_AbstractEnvironment$get_debugInfo() {
        return this._debugInfo;
    },
    
    _fetchDebugInfo: function Framework_AbstractEnvironment$_fetchDebugInfo() {
        Framework.AbstractEnvironment._log.debug('FetchDebugInfo');
        this.invokeAsync('DebugService', 'GetDebugInfo', {}, Delegate.create(this, function(result) {
            this._debugInfo = result;
        }), Delegate.create(this, function(exception) {
        }));
    },
    
    getCookie: function Framework_AbstractEnvironment$getCookie(name) {
        return Framework.CookieUtil.getCookie(name);
    },
    
    setCookie: function Framework_AbstractEnvironment$setCookie(name, value) {
        Framework.CookieUtil.setCookie(name, value);
    },
    
    setCookieWithDays: function Framework_AbstractEnvironment$setCookieWithDays(name, value, numberOfDays) {
        Framework.CookieUtil.setCookieWithDays(name, value, numberOfDays);
    },
    
    clearCookie: function Framework_AbstractEnvironment$clearCookie(name) {
        Framework.CookieUtil.clearCookie(name);
    },
    
    clearCookies: function Framework_AbstractEnvironment$clearCookies() {
        Framework.CookieUtil.clearCookies();
    },
    
    _setCurrentCulture: function Framework_AbstractEnvironment$_setCurrentCulture(cultureKey) {
        var cultures = Framework.CustomCultureInfo.getCustomCultures();
        if (Object.keyExists(cultures, cultureKey) && Type.getInstanceType(cultures[cultureKey]) === CultureInfo) {
            CultureInfo.Current = cultures[cultureKey];
        }
    },
    
    getBaselineUrl: function Framework_AbstractEnvironment$getBaselineUrl(isSecure) {
        return window.location.href.substr(0, window.location.href.toUpperCase().indexOf('AREAS')).replace(new RegExp('^http[s]*:'), (isSecure) ? 'https:' : 'http:');
    },
    
    _calculateHash: function Framework_AbstractEnvironment$_calculateHash(pageFilter, putHashOnStart) {
        var result = (putHashOnStart) ? '#' : String.Empty;
        var current = 0;
        var $dict1 = pageFilter;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (!String.isNullOrEmpty(entry.key) && !String.isNullOrEmpty(entry.value)) {
                result += String.format('{0}{1}={2}', (!current++) ? String.Empty : '&', entry.key, entry.value);
            }
        }
        return result;
    },
    
    getHash: function Framework_AbstractEnvironment$getHash(pageFilter) {
        throw new Error('Not implemented');
    },
    
    setHash: function Framework_AbstractEnvironment$setHash(pageFilter) {
        var hash = this._calculateHash(pageFilter, false);
        if (!isNullOrUndefined(hash) && !String.isNullOrEmpty(hash)) {
            try {
                var historyManager = ScriptFX.Application.current.get_history();
                if (historyManager) {
                    historyManager.addEntry(hash);
                }
            }
            catch ($e1) {
            }
        }
        window.location.hash = hash;
    },
    
    changeLocation: function Framework_AbstractEnvironment$changeLocation(pageArea, pageFilter, storeServicesStates, protocol) {
        this.firePageWillChangeEvent();
        var url = '/Areas/' + pageArea + '/Template_' + this._region + '_' + this._language + '/index.html';
        var hash = this._calculateHash(pageFilter, false);
        if (!isNullOrUndefined(hash) && !String.isNullOrEmpty(hash)) {
            ScriptFX.Application.current.get_history().addEntry(hash);
        }
        var completeURL = '';
        if (!String.isNullOrEmpty(protocol)) {
            completeURL = String.format('{0}://{1}{2}{3}', protocol, window.location.hostname, ((window.location.port.toString() === '') || (window.location.port === 80) || (window.location.port === 443)) ? '' : (':' + window.location.port), url);
            window.navigate(completeURL + '#' + hash);
        }
        else {
            window.navigate(url + '#' + hash);
        }
    },
    
    buildUrl: function Framework_AbstractEnvironment$buildUrl(pageArea, pageFilter, protocol) {
        var url = '/Areas/' + pageArea + '/Template_' + this._region + '_' + this._language + '/index.html';
        var isFirst = true;
        var $dict1 = pageFilter;
        for (var $key2 in $dict1) {
            var dictionaryEntry = { key: $key2, value: $dict1[$key2] };
            if (dictionaryEntry.key && dictionaryEntry.value) {
                url += String.format('{0}{1}={2}', ((isFirst) ? '#' : '&'), dictionaryEntry.key, dictionaryEntry.value);
                isFirst = false;
            }
        }
        if (String.isNullOrEmpty(window.location.port.toString())) {
            url = String.format('{0}://{1}{2}', (String.isNullOrEmpty(protocol)) ? this.getProtocol() : protocol, window.location.hostname, url);
        }
        return url;
    },
    
    changeRegion: function Framework_AbstractEnvironment$changeRegion(region, pageArea, pageFilter) {
        this._region = region;
        this.changeLocation(pageArea, pageFilter, true, String.Empty);
    },
    
    changeLanguage: function Framework_AbstractEnvironment$changeLanguage(language, pageArea, pageFilter) {
        this._language = language;
        this.changeLocation(pageArea, pageFilter, true, String.Empty);
    },
    
    safelySetCssClass: function Framework_AbstractEnvironment$safelySetCssClass(domElementId, className) {
        var element = document.getElementById(domElementId);
        this.safelySetCssClassOnElement(element, className);
    },
    
    safelyRemoveCssClass: function Framework_AbstractEnvironment$safelyRemoveCssClass(domElementId, className) {
        var element = document.getElementById(domElementId);
        this.safelyRemoveCssClassOnElement(element, className);
    },
    
    safelySetAndUnsetCssClass: function Framework_AbstractEnvironment$safelySetAndUnsetCssClass(domElementId, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(domElementId) || String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        var element = document.getElementById(domElementId);
        this.safelySetAndUnsetCssClassOnElement(element, classNameToSet, classNameToUnset);
    },
    
    safelySetAndUnsetCssClassIf: function Framework_AbstractEnvironment$safelySetAndUnsetCssClassIf(value, domElementId, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(domElementId) || String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        var element = document.getElementById(domElementId);
        this.safelySetAndUnsetCssClassOnElementIf(value, element, classNameToSet, classNameToUnset);
    },
    
    containsCssClass: function Framework_AbstractEnvironment$containsCssClass(domElementId, className) {
        var element = document.getElementById(domElementId);
        return this.containsCssClassOnElement(element, className);
    },
    
    safelySetCssClassOnElement: function Framework_AbstractEnvironment$safelySetCssClassOnElement(domElement, className) {
        if (domElement && !String.isNullOrEmpty(className)) {
            ScriptFX.UI.Element.addCSSClass(domElement, className);
        }
    },
    
    safelyRemoveCssClassOnElement: function Framework_AbstractEnvironment$safelyRemoveCssClassOnElement(domElement, className) {
        if (domElement && !String.isNullOrEmpty(className)) {
            ScriptFX.UI.Element.removeCSSClass(domElement, className);
        }
    },
    
    safelySetAndUnsetCssClassOnElement: function Framework_AbstractEnvironment$safelySetAndUnsetCssClassOnElement(domElement, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        if (domElement) {
            ScriptFX.UI.Element.addCSSClass(domElement, classNameToSet);
            ScriptFX.UI.Element.removeCSSClass(domElement, classNameToUnset);
        }
    },
    
    safelySetAndUnsetCssClassOnElementIf: function Framework_AbstractEnvironment$safelySetAndUnsetCssClassOnElementIf(value, domElement, classNameToSet, classNameToUnset) {
        if (String.isNullOrEmpty(classNameToSet) || String.isNullOrEmpty(classNameToUnset)) {
            return;
        }
        if (domElement) {
            if (value) {
                ScriptFX.UI.Element.addCSSClass(domElement, classNameToSet);
                ScriptFX.UI.Element.removeCSSClass(domElement, classNameToUnset);
            }
            else {
                ScriptFX.UI.Element.addCSSClass(domElement, classNameToUnset);
                ScriptFX.UI.Element.removeCSSClass(domElement, classNameToSet);
            }
        }
    },
    
    containsCssClassOnElement: function Framework_AbstractEnvironment$containsCssClassOnElement(domElement, className) {
        if (domElement && !String.isNullOrEmpty(className)) {
            return ScriptFX.UI.Element.containsCSSClass(domElement, className);
        }
        return false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractService

Framework.AbstractService = function Framework_AbstractService() {
}
Framework.AbstractService.prototype = {
    _environment: null,
    _parameters: null,
    
    init: function Framework_AbstractService$init(environment, parameters) {
        this._environment = environment;
        this._parameters = parameters;
    },
    
    hello: function Framework_AbstractService$hello(name) {
        var arguments = {};
        arguments['name'] = name;
        return this._environment.invoke(Type.getInstanceType(this).get_name(), 'Hello', arguments);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ComponentInfo

Framework.ComponentInfo = function Framework_ComponentInfo(positionName, componentName, componentNameOri) {
    this.positionName = positionName;
    this.componentName = componentName;
    this.componentNameOri = componentNameOri;
}
Framework.ComponentInfo.prototype = {
    positionName: null,
    componentName: null,
    componentNameOri: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.PagerCall

Framework.PagerCall = function Framework_PagerCall(action, pagenumber, args) {
    this.action = action;
    this.pagenumber = pagenumber;
    this.args = args;
}
Framework.PagerCall.prototype = {
    action: null,
    pagenumber: 0,
    args: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.MessageIndicators

Framework.MessageIndicators = function Framework_MessageIndicators() {
}
Framework.MessageIndicators.getIndicator = function Framework_MessageIndicators$getIndicator(key, prefix) {
    if (isNullOrUndefined(prefix)) {
        prefix = 'messageIndicator_';
    }
    var indicatorCtl = document.getElementById(prefix + key);
    if (isNullOrUndefined(indicatorCtl)) {
        return 'false';
    }
    return indicatorCtl.value;
}
Framework.MessageIndicators.isIndicatorTrue = function Framework_MessageIndicators$isIndicatorTrue(key, prefix) {
    return Framework.MessageIndicators.getIndicator(key, prefix) === Framework.MessageIndicators.trueVal;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Pager

Framework.Pager = function Framework_Pager() {
}
Framework.Pager.getPage = function Framework_Pager$getPage(containerId, action, pagenumber, args, onCompleteDelegate) {
    var container = document.getElementById(containerId);
    if (!container) {
        return;
    }
    Framework.AbstractEnvironment.safeUpdateDomElementDirect(container, '<span class=\'waiting\'>&nbsp;</span>Loading, please wait...');
    Framework.PagerLastCall.setLastCall(containerId + '|' + action, new Framework.PagerCall(action, pagenumber, args));
    if (!onCompleteDelegate) {
        onCompleteDelegate = Framework.Pager.defaultCallBack;
    }
    var url = String.format('{0}.rails?pagenumber={1}', action, pagenumber);
    var $dict1 = args;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        url += String.format('&{0}={1}', entry.key, entry.value);
    }
    var ajax = new Framework.AjaxUpdater(containerId, url, onCompleteDelegate, null);
    ajax.evalScripts = true;
    ajax.update();
}
Framework.Pager.getPageAgain = function Framework_Pager$getPageAgain(containerId, action, defaultargs, onCompleteDelegate) {
    var lastCall = Framework.PagerLastCall.getLastCall(containerId + '|' + action);
    if (lastCall) {
        Framework.Pager.getPage(containerId, lastCall.action, lastCall.pagenumber, lastCall.args, onCompleteDelegate);
    }
    else {
        Framework.Pager.getPage(containerId, action, 1, defaultargs, onCompleteDelegate);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.PagerLastCall

Framework.PagerLastCall = function Framework_PagerLastCall() {
}
Framework.PagerLastCall.setLastCall = function Framework_PagerLastCall$setLastCall(key, args) {
    Framework.PagerLastCall._callsByContainerId[key] = args;
}
Framework.PagerLastCall.getLastCall = function Framework_PagerLastCall$getLastCall(key) {
    var o = Framework.PagerLastCall._callsByContainerId[key];
    return ((!o) ? null : o);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.BubblingEvent

Framework.BubblingEvent = function Framework_BubblingEvent() {
}
Framework.BubblingEvent.parse = function Framework_BubblingEvent$parse(evt) {
    return ((evt));
}
Framework.BubblingEvent.prototype = {
    
    stopPropagation: function Framework_BubblingEvent$stopPropagation() {
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminClassNames

Framework.AdminClassNames = function Framework_AdminClassNames() {
}
Framework.AdminClassNames.prototype = {
    placeHolder: null,
    component: null,
    placeHolderHover: null,
    placeHolderSelected: null,
    parameter: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminUrls

Framework.AdminUrls = function Framework_AdminUrls() {
}
Framework.AdminUrls.prototype = {
    showParams: null,
    removeComponent: null,
    storeParams: null,
    save: null,
    revert: null,
    back: null,
    findComponents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminPageIds

Framework.AdminPageIds = function Framework_AdminPageIds() {
}
Framework.AdminPageIds.prototype = {
    componentToolboxId: null,
    pageAreaToolboxId: null,
    adminMessageToolboxId: null,
    propertiesToolboxId: null,
    areaname: null,
    componentPropertiesId: null,
    messageBoxId: null,
    componentListId: null,
    savebuttonId: null,
    revertButtonId: null,
    backbuttonId: null,
    componentNameFilterId: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminUtil

Framework.AdminUtil = function Framework_AdminUtil() {
}
Framework.AdminUtil.prototype = {
    wiring: null,
    showMessage: null,
    currentComponentConfiguration: null,
    showComponentProperties: null,
    getElementsBySelector: null,
    cancelEdit: null,
    parseIndicators: null,
    
    isElementVisible: function Framework_AdminUtil$isElementVisible(id) {
        var element = document.getElementById(id);
        if (element && element.style.display.toLowerCase() !== 'none') {
            return true;
        }
        return false;
    },
    
    setVisibilityById: function Framework_AdminUtil$setVisibilityById(elementId, visible) {
        this.setVisibility(document.getElementById(elementId), visible);
    },
    
    setVisibility: function Framework_AdminUtil$setVisibility(element, visible) {
        if (element) {
            element.style.display = ((visible) ? '' : 'none');
        }
    },
    
    isToolboxElement: function Framework_AdminUtil$isToolboxElement(element) {
        if (element && element.tagName === 'SPAN' && element.parentNode.tagName === 'LI') {
            return true;
        }
        else {
            return false;
        }
    },
    
    setToolBoxVisibility: function Framework_AdminUtil$setToolBoxVisibility(visible, ids) {
        this.setVisibilityById(ids.componentToolboxId, visible);
        this.setVisibilityById(ids.pageAreaToolboxId, visible);
        this.setVisibilityById(ids.adminMessageToolboxId, visible);
    },
    
    confirmation: function Framework_AdminUtil$confirmation(componentName, positionName, action) {
        var c = confirm(String.format('Are you sure you want to {0} {1} in {2}?', action, componentName, positionName));
        if (c) {
            return true;
        }
        else {
            return false;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminDragController

Framework.AdminDragController = function Framework_AdminDragController(dragArgs, util, ids) {
    this._dragstartLocation = new Framework.Position(0, 0);
    this._args = dragArgs;
    this._ids = ids;
    this._util = util;
}
Framework.AdminDragController.prototype = {
    _ids: null,
    _args: null,
    _util: null,
    _isDragging: false,
    _currentDrop: null,
    
    isDragging: function Framework_AdminDragController$isDragging() {
        return this._isDragging;
    },
    
    getCurrentDrop: function Framework_AdminDragController$getCurrentDrop() {
        return this._currentDrop;
    },
    
    onDragComponentStart: function Framework_AdminDragController$onDragComponentStart(e) {
        this._isDragging = true;
        var pos = Framework.DragController.getAbsolutePosition(e.srcElement);
        Framework.Droppables.setOffset(pos.x, pos.y);
        return false;
    },
    
    onDragComponentEnd: function Framework_AdminDragController$onDragComponentEnd(obj, x, y) {
        this._isDragging = false;
        this._util.cancelEdit.invoke();
        if (!obj) {
            return;
        }
        this._args.dragsRefresh.invoke();
        var drop = Framework.Droppables.getDroppable(x, y);
        if (!drop) {
            return;
        }
        this._util.currentComponentConfiguration = null;
        this._util.showComponentProperties.invoke(drop.id, obj.id);
        this._util.setToolBoxVisibility(false, this._ids);
    },
    
    onDrag: function Framework_AdminDragController$onDrag(obj, x, y) {
        var drop = Framework.Droppables.getDroppable(x, y);
        if (!drop || drop !== this._currentDrop) {
            if (this._currentDrop) {
                this._currentDrop.className = this._args.dropClassName;
            }
            if (drop) {
                drop.className = this._args.dropHoverClassName;
            }
            this._currentDrop = drop;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AdminController

Framework.AdminController = function Framework_AdminController(util, classNames, urls, ids) {
    this._ids = ids;
    this._util = util;
    if (isNullOrUndefined(util.parseIndicators)) {
        util.parseIndicators = Delegate.create(this, this.parseIndicators);
    }
    if (isNullOrUndefined(util.showComponentProperties)) {
        util.showComponentProperties = Delegate.create(this, this.showComponentProperties);
    }
    if (isNullOrUndefined(util.showMessage)) {
        util.showMessage = Delegate.create(this, this.showMessage);
    }
    if (isNullOrUndefined(util.cancelEdit)) {
        util.cancelEdit = Delegate.create(this, this.cancelComponentEditing);
    }
    var dragArgs = new Framework.DragArgs();
    dragArgs.dragsRefresh = Delegate.create(this, this.refreshComponents);
    dragArgs.dropClassName = classNames.placeHolder;
    dragArgs.dropHoverClassName = classNames.placeHolderHover;
    dragArgs.dragClassName = classNames.component;
    this._dragController = new Framework.AdminDragController(dragArgs, util, ids);
    this._classNames = classNames;
    this._urls = urls;
    this.componentOnClickHandler = Delegate.create(this, this.componentOnClickHandle);
    var ctl = document.getElementById(this._ids.backbuttonId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onclick', Delegate.create(this, this.goBack));
    }
    ctl = document.getElementById(this._ids.savebuttonId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onclick', Delegate.create(this, this.saveArea));
    }
    ctl = document.getElementById(this._ids.revertButtonId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onclick', Delegate.create(this, this.revertArea));
    }
    ctl = document.getElementById(this._ids.componentNameFilterId);
    if (!isNullOrUndefined(ctl)) {
        ctl.attachEvent('onkeyup', Delegate.create(this, this.findComponentsHandler));
    }
    this.findComponents('');
    this.buildIndexMaps();
}
Framework.AdminController.prototype = {
    _ids: null,
    _urls: null,
    _util: null,
    _dragController: null,
    _classNames: null,
    _editingComponent: null,
    _currentComponentConfiguration: null,
    _storedComponentInfo: null,
    _ComponentIndexMap: null,
    _PlaceHolderNextIndexMap: null,
    
    buildIndexMaps: function Framework_AdminController$buildIndexMaps() {
        this._ComponentIndexMap = {};
        this._PlaceHolderNextIndexMap = {};
        var positions = this._util.getElementsBySelector.invoke('.' + this._classNames.placeHolder);
        if (!isNullOrUndefined(positions)) {
            for (var i = 0; i < positions.length; i++) {
                var components = positions[i].childNodes;
                var nextIndex = 0;
                if (!isNullOrUndefined(components)) {
                    for (var j = 0; j < components.length; j++) {
                        if (!isNullOrUndefined(components[j].id)) {
                            this._ComponentIndexMap[components[j].id] = nextIndex;
                            nextIndex++;
                        }
                    }
                }
                this._PlaceHolderNextIndexMap[positions[i].id] = nextIndex;
            }
        }
    },
    
    getComponentIndex: function Framework_AdminController$getComponentIndex(componentName) {
        return this._ComponentIndexMap[componentName];
    },
    
    setComponentIndex: function Framework_AdminController$setComponentIndex(componentName, index) {
        this._ComponentIndexMap[componentName] = index;
    },
    
    getNextComponentIndex: function Framework_AdminController$getNextComponentIndex(placeholderName) {
        var next = this._PlaceHolderNextIndexMap[placeholderName];
        if (isNullOrUndefined(next)) {
            next = 0;
        }
        this._PlaceHolderNextIndexMap[placeholderName] = next + 1;
        return next;
    },
    
    setUpDraggables: function Framework_AdminController$setUpDraggables() {
        var containers = this._util.getElementsBySelector.invoke('.' + this._classNames.component);
        for (var i = 0; i < containers.length; i++) {
            var d = containers[i];
            if (d && this._util.isToolboxElement(d)) {
                var dctl = new Framework.DragController(d, null, null, null, null, null, false, false, null, null);
                d.onDragEnd = Delegate.create(this._dragController, this._dragController.onDragComponentEnd);
                d.onDrag = Delegate.create(this._dragController, this._dragController.onDrag);
                d.onDragStart = Delegate.create(this._dragController, this._dragController.onDragComponentStart);
            }
        }
    },
    
    showMessage: function Framework_AdminController$showMessage(message) {
        var e = document.getElementById(this._ids.messageBoxId);
        if (!isNullOrUndefined(e)) {
            this._util.setVisibility(e.parentNode, true);
            Framework.AbstractEnvironment.safeUpdateDomElementDirect(e, '<span class=\'waiting\'>&nbsp;</span>' + message);
        }
    },
    
    setUpDroppables: function Framework_AdminController$setUpDroppables() {
        var positions = this._util.getElementsBySelector.invoke('.' + this._classNames.placeHolder);
        for (var i = 0; i < positions.length; i++) {
            positions[i].innerHTML = positions[i].innerHTML + '&nbsp;';
            Framework.Droppables.add(positions[i]);
        }
    },
    
    setUpClickables: function Framework_AdminController$setUpClickables() {
        var allComponents = this._util.getElementsBySelector.invoke('.' + this._classNames.component);
        for (var i = 0; i < allComponents.length; i++) {
            if (allComponents[i] && !this._util.isToolboxElement(allComponents[i])) {
                this.setComponentClick(allComponents[i]);
            }
        }
    },
    
    setComponentClick: function Framework_AdminController$setComponentClick(element) {
        try {
            if (isNullOrUndefined(element)) {
                return;
            }
            if (isNullOrUndefined(element.tagName)) {
                return;
            }
            if (element.tagName.toUpperCase() === 'A') {
                element.setAttribute('href', '#');
                element.setAttribute('onclick', 'return false;');
            }
            if (element.tagName.toUpperCase() === 'INPUT') {
                element.setAttribute('onclick', 'return false;');
            }
            element.attachEvent('onclick', this.componentOnClickHandler);
            var childNodes = element.childNodes;
            if (!childNodes) {
                return;
            }
            for (var i = 0; i < childNodes.length; i++) {
                this.setComponentClick(childNodes[i]);
            }
        }
        catch ($e1) {
        }
    },
    
    getElementForClassNames: function Framework_AdminController$getElementForClassNames(element, classNames) {
        var $enum1 = classNames.getEnumerator();
        while ($enum1.moveNext()) {
            var className = $enum1.get_current();
            if (element.className === className) {
                return element;
            }
        }
        var parent = element.parentNode;
        if (parent) {
            return this.getElementForClassNames(parent, classNames);
        }
        return null;
    },
    
    getPlaceHolder: function Framework_AdminController$getPlaceHolder(element) {
        return this.getElementForClassNames(element, [ this._classNames.placeHolder, this._classNames.placeHolderHover ]);
    },
    
    getComponent: function Framework_AdminController$getComponent(element) {
        return this.getElementForClassNames(element, [ this._classNames.component ]);
    },
    
    componentOnClick: function Framework_AdminController$componentOnClick(evt) {
        var placeHolder = this.getPlaceHolder(evt.srcElement);
        var component = this.getComponent(evt.srcElement);
        if (placeHolder && component) {
            window.event.cancelBubble = true;
            if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
                window.event.cancelBubble = true;
            }
            else {
                Framework.BubblingEvent.parse(evt).stopPropagation();
            }
            this.editPositionComponent(component.id, placeHolder.id);
        }
    },
    
    checkComponentProperties: function Framework_AdminController$checkComponentProperties() {
        var hasUnfilledParams = document.getElementById('hasUnfilledParams');
        if (!this._editingComponent && hasUnfilledParams && hasUnfilledParams.value === 'False') {
            this._util.setVisibilityById(this._ids.propertiesToolboxId, false);
            var positionName = document.getElementById('positionName');
            var componentName = document.getElementById('componentName');
            var componentIndex = document.getElementById('componentIndex');
            if (!isNullOrUndefined(positionName) && !isNullOrUndefined(componentName) && !isNullOrUndefined(componentIndex)) {
                this.saveParameters(positionName.value, componentName.value, Number.parse(componentIndex.value));
            }
        }
    },
    
    showComponentProperties: function Framework_AdminController$showComponentProperties(positionName, componentName) {
        var propertiesToolbox = document.getElementById(this._ids.propertiesToolboxId);
        if (isNullOrUndefined(propertiesToolbox)) {
            return;
        }
        var propertiesContainer = document.getElementById(this._ids.componentPropertiesId);
        if (isNullOrUndefined(propertiesContainer)) {
            return;
        }
        var index = this.getComponentIndex(componentName);
        if (isNullOrUndefined(index)) {
            index = this.getNextComponentIndex(positionName);
        }
        this._util.setVisibility(propertiesToolbox, true);
        Framework.AbstractEnvironment.safeUpdateDomElementDirect(propertiesContainer, '<span class=\'waiting\'>&nbsp;</span>Loading, please wait...');
        var url = String.format('{0}.rails?areaname={1}&positionName={2}&componentName={3}&componentIndex={4}', this._urls.showParams, this._ids.areaname, positionName, componentName, index);
        var ajax = new Framework.AjaxUpdater(this._ids.componentPropertiesId, url, Delegate.create(this, this.checkComponentProperties), null);
        ajax.evalScripts = true;
        ajax.update();
    },
    
    clearSelections: function Framework_AdminController$clearSelections() {
        var allComponents = this._util.getElementsBySelector.invoke('.' + this._classNames.placeHolderSelected);
        for (var i = 0; i < allComponents.length; i++) {
            allComponents[i].className = this._classNames.component;
        }
    },
    
    editPositionComponent: function Framework_AdminController$editPositionComponent(componentName, positionName) {
        if (this.isAddingComponent()) {
            return;
        }
        this.clearSelections();
        this._editingComponent = document.getElementById(componentName);
        this._currentComponentConfiguration = this._util.wiring.getComponentConfiguration(componentName);
        this.showComponentProperties(positionName, componentName);
    },
    
    cancelAddComponent: function Framework_AdminController$cancelAddComponent(positionName, componentName, index) {
        this._util.setVisibilityById(this._ids.propertiesToolboxId, false);
        this._util.setVisibilityById(this._ids.adminMessageToolboxId, false);
        this._util.setVisibilityById(this._ids.componentToolboxId, true);
        var position = document.getElementById(positionName);
        if (position) {
            position.className = this._classNames.placeHolder;
        }
        this._editingComponent = null;
    },
    
    isAddingComponent: function Framework_AdminController$isAddingComponent() {
        if (this._dragController.isDragging()) {
            return true;
        }
        document.getElementById(this._ids.componentToolboxId);
        return !this._util.isElementVisible(this._ids.componentToolboxId);
    },
    
    removeComponent: function Framework_AdminController$removeComponent(positionName, componentName, index) {
        var args = String.format('areaname={0}&positionName={1}&componentName={2}&componentIndex={3}', this._ids.areaname, positionName, componentName, index);
        this._util.showMessage.invoke('Removing component parameter values, please wait...');
        var url = String.format('{0}.rails?{1}', this._urls.removeComponent, args);
        var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
        ajax.evalScripts = true;
        ajax.update();
    },
    
    saveParameters: function Framework_AdminController$saveParameters(positionName, componentName, index) {
        var args = String.format('areaname={0}&positionName={1}&componentName={2}&componentIndex={3}', this._ids.areaname, positionName, componentName, index);
        if (!this._currentComponentConfiguration) {
            this._currentComponentConfiguration = new Framework.ComponentConfiguration(componentName + '.' + componentName, null, new Array(0), {}, null, {});
        }
        this.setComponentIndex(componentName, index);
        var nextIndex = this._PlaceHolderNextIndexMap[positionName];
        if (index >= nextIndex) {
            this._PlaceHolderNextIndexMap[positionName] = index + 1;
        }
        var allParameters = this._util.getElementsBySelector.invoke('.' + this._classNames.parameter);
        for (var i = 0; i < allParameters.length; i++) {
            var node = allParameters[i];
            args += '&' + node.id + '=';
            if (node.type.toLowerCase() === 'checkbox') {
                this._currentComponentConfiguration.parameters[node.id] = (node).checked;
                args += (node).checked;
            }
            else {
                this._currentComponentConfiguration.parameters[node.id] = node.value;
                args += node.value;
            }
        }
        this._util.showMessage.invoke('Storing component parameter values, please wait...');
        var url = String.format('{0}.rails?{1}', this._urls.storeParams, args);
        var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
        var componentNameOri = componentName;
        var componentNameOriElement = document.getElementById('componentNameOri');
        if (!isNullOrUndefined(componentNameOriElement)) {
            componentNameOri = componentNameOriElement.value;
        }
        this._storedComponentInfo = new Framework.ComponentInfo(positionName, componentNameOri, componentNameOri);
        ajax.evalScripts = true;
        ajax.update();
    },
    
    ensureComponent: function Framework_AdminController$ensureComponent(positionName, componentName) {
        if (this._editingComponent) {
            this._util.wiring.updateComponent(this._storedComponentInfo.componentNameOri, this._currentComponentConfiguration);
        }
        else {
            this._util.wiring.addComponent(this._storedComponentInfo.componentNameOri, this._currentComponentConfiguration, positionName);
        }
        this._currentComponentConfiguration = null;
    },
    
    saveArea: function Framework_AdminController$saveArea() {
        if (this._util.confirmation('all changes', this._ids.areaname, 'save')) {
            this._util.showMessage.invoke('Saving all stored values, please wait...');
            var url = String.format('{0}.rails?areaname={1}', this._urls.save, this._ids.areaname);
            var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
            ajax.evalScripts = true;
            ajax.update();
        }
    },
    
    revertArea: function Framework_AdminController$revertArea() {
        if (this._util.confirmation('all unsaved changes', this._ids.areaname, 'undo')) {
            this._util.showMessage.invoke('Undoing all stored values, please wait...');
            var url = String.format('{0}.rails?areaname={1}', this._urls.revert, this._ids.areaname);
            var ajax = new Framework.AjaxUpdater(this._ids.messageBoxId, url, this._util.parseIndicators, null);
            ajax.evalScripts = true;
            ajax.update();
        }
    },
    
    findComponentsHandler: function Framework_AdminController$findComponentsHandler() {
        var evt = this._getWindowEvent();
        var ctl = evt.srcElement;
        var findString = '';
        if (!isNullOrUndefined(ctl)) {
            findString = ctl.value;
        }
        this.findComponents(findString);
    },
    
    findComponents: function Framework_AdminController$findComponents(findString) {
        Framework.Pager.getPage(this._ids.componentListId, this._urls.findComponents, 1, { nameContains: findString }, null);
    },
    
    refreshComponents: function Framework_AdminController$refreshComponents() {
        Framework.Pager.getPageAgain(this._ids.componentListId, this._urls.findComponents, { nameContains: '' }, null);
    },
    
    goBack: function Framework_AdminController$goBack() {
        window.navigate(this._urls.back);
    },
    
    componentOnClickHandle: function Framework_AdminController$componentOnClickHandle() {
        this.componentOnClick(this._getWindowEvent());
    },
    
    componentOnClickHandler: null,
    
    _getWindowEvent: function Framework_AdminController$_getWindowEvent() {
        return window.event;
    },
    
    parseIndicators: function Framework_AdminController$parseIndicators() {
        var runForAdmin = false;
        if (Framework.MessageIndicators.isIndicatorTrue('RemoveComponent', null)) {
            if (this._editingComponent) {
                runForAdmin = true;
                this._util.wiring.removeComponent(this._editingComponent.id);
                this._currentComponentConfiguration = null;
            }
        }
        if (Framework.MessageIndicators.isIndicatorTrue('ShowComponents', null)) {
            this._util.setVisibilityById(this._ids.componentToolboxId, true);
            this._util.setVisibilityById(this._ids.pageAreaToolboxId, true);
            var currentDrop = this._dragController.getCurrentDrop();
            if (!isNullOrUndefined(currentDrop)) {
                currentDrop.className = this._classNames.placeHolder;
                currentDrop = null;
            }
            if (!isNullOrUndefined(this._storedComponentInfo)) {
                runForAdmin = true;
                this.ensureComponent(this._storedComponentInfo.positionName, this._storedComponentInfo.componentName);
            }
            this._storedComponentInfo = null;
        }
        if (Framework.MessageIndicators.isIndicatorTrue('HideParameters', null)) {
            this.cancelComponentEditing();
        }
        if (Framework.MessageIndicators.isIndicatorTrue('RevertAll', null)) {
            eval('window.location.reload();');
        }
        if (runForAdmin) {
            this._util.wiring.runForAdmin();
            window.setTimeout(Delegate.create(this, this.setUpClickables), 1000);
            window.setTimeout(Delegate.create(this, this.buildIndexMaps), 1000);
        }
    },
    
    cancelComponentEditing: function Framework_AdminController$cancelComponentEditing() {
        if (!isNullOrUndefined(this._editingComponent)) {
            this._util.setVisibilityById(this._ids.propertiesToolboxId, false);
            this.clearSelections();
            this._editingComponent = null;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AutoWiring

Framework.AutoWiring = function Framework_AutoWiring() {
    this._services = {};
    this._components = {};
    this._dynamicComponents = {};
}
Framework.AutoWiring.prototype = {
    _serviceConfiguration: null,
    _componentConfiguration: null,
    _componentPlacementMap: null,
    _environment: null,
    
    getComponents: function Framework_AutoWiring$getComponents() {
        return this._components;
    },
    
    getServices: function Framework_AutoWiring$getServices() {
        return this._services;
    },
    
    init: function Framework_AutoWiring$init(servicesConfigurations, componentsConfiguration, dynamicComponentsConfiguration, componentsPlacementMap, encodedXsltDocumentsMap) {
        Framework.CookieUtil.clearCookie(Framework.AutoWiring._ssrUserCookieName);
        this._serviceConfiguration = servicesConfigurations;
        this._componentConfiguration = componentsConfiguration;
        this._dynamicComponents = dynamicComponentsConfiguration;
        this._componentPlacementMap = componentsPlacementMap;
        var $dict1 = encodedXsltDocumentsMap;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var document = XMLDocumentParser.parse(entry.value);
            Framework.Component.Updating.UpdateXsltBasedComponentTask.storeXsltDocument(entry.key, document);
            Framework.TransformAndUpdateTask.storeXsltDocument(entry.key, document);
        }
    },
    
    _initDebuggingLayer: function Framework_AutoWiring$_initDebuggingLayer() {
        var div1 = document.createElement('div');
        div1.setAttribute('class', 'debug-layer');
        var img = document.createElement('img');
        img.setAttribute('alt', 'debug');
        img.setAttribute('src', '../../../bug.png');
        img.setAttribute('onclick', 'if ($(\'debug-area\').style.display == \'none\') $(\'debug-area\').style.display = \'block\'; else $(\'debug-area\').style.display = \'none\';');
        div1.appendChild(img);
        var div2 = document.createElement('div');
        div2.setAttribute('id', 'debug-area');
        div2.setAttribute('class', 'debug-area');
        div2.setAttribute('style', 'display : none');
        div1.appendChild(div2);
        var input1 = document.createElement('input');
        input1.setAttribute('type', 'button');
        input1.setAttribute('value', 'Clear Debug');
        input1.setAttribute('onclick', '$(\'debug\').innerHTML=\'\';');
        div2.appendChild(input1);
        var input2 = document.createElement('input');
        input2.setAttribute('type', 'button');
        input2.setAttribute('value', 'Switch');
        input2.setAttribute('onclick', 'Framework._log.switchLogging();');
        div2.appendChild(input2);
        var br = document.createElement('br');
        div2.appendChild(br);
        var div3 = document.createElement('div');
        div3.setAttribute('id', 'debug');
        div3.setAttribute('class', 'debug');
        div2.appendChild(div3);
        document.getElementsByTagName('body')[0].insertBefore(div1, document.getElementsByTagName('body')[0].childNodes[0]);
    },
    
    _initEnvironment: function Framework_AutoWiring$_initEnvironment() {
        Framework.AutoWiring._log.debug('InitEnvironment');
        var initialPageFilter = {};
        var parts = (new RegExp('/([^/]*)/[Tt][Ee][Mm][Pp][Ll][Aa][Tt][Ee]_([^_]*)_([^/]*)/')).exec(window.location.toString());
        var initialPageArea = parts[1];
        Framework.AutoWiring._log.debug('Extracted initial page area ' + initialPageArea);
        var initialRegion = parts[2];
        Framework.AutoWiring._log.debug('Extracted initial region ' + initialRegion);
        var initialLanguage = parts[3];
        Framework.AutoWiring._log.debug('Extracted initial language ' + initialLanguage);
        var searchTokens = ((window.location.search.startsWith('?')) ? window.location.search.substr(1) : window.location.search).split(new RegExp('\\&|='));
        var debug = false;
        for (var i = 0; i < searchTokens.length; i += 2) {
            var name = searchTokens[i];
            var value = (i + 1 < searchTokens.length) ? searchTokens[i + 1] : null;
            if (String.equals('debug', name, true)) {
                this._initDebuggingLayer();
                Framework.Logger.switchLogging();
                debug = true;
            }
            else if (String.equals('maxlogsize', name, true)) {
                Framework.Logger.setMaximumLogSize(Number.parse(value));
            }
            else {
                initialPageFilter[name] = value;
            }
        }
        var hashTokens = ((window.location.hash.startsWith('#')) ? window.location.hash.substr(1) : window.location.hash).split(new RegExp('\\&|='));
        for (var i = 0; i < hashTokens.length; i += 2) {
            var name = hashTokens[i];
            var value = (i + 1 < hashTokens.length) ? hashTokens[i + 1] : null;
            Framework.AutoWiring._log.debug(String.format('Processing hash tokens [{0}] [{1}]', name, value));
            if (value) {
                initialPageFilter[name] = value;
            }
        }
        Framework.AbstractEnvironment._debugMode = debug;
        this._environment = Framework.AbstractEnvironment.createInstance(this._components, this._dynamicComponents, this._services);
        this._environment.init(initialLanguage, initialRegion, initialPageArea, initialPageFilter);
    },
    
    _initServices: function Framework_AutoWiring$_initServices() {
        Framework.AutoWiring._log.debug('InitServices');
        var $dict1 = this._serviceConfiguration;
        for (var $key2 in $dict1) {
            var serviceConfigurationDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var serviceName = serviceConfigurationDictionaryEntry.key;
            Framework.AutoWiring._log.debug(String.format('Processing {0}', serviceName));
            var serviceConfiguration = serviceConfigurationDictionaryEntry.value;
            var serviceType = Type.getType(serviceConfiguration.className);
            var service = new serviceType();
            this._services[serviceName] = service;
            service.init(this._environment, serviceConfiguration.parameters);
        }
        var $dict3 = this._services;
        for (var $key4 in $dict3) {
            var serviceDictionaryEntry = { key: $key4, value: $dict3[$key4] };
            var serviceName = serviceDictionaryEntry.key;
            Framework.AutoWiring._log.debug(String.format('Connecting services to {0}', serviceName));
            var service = serviceDictionaryEntry.value;
            var serviceConfiguration = this._serviceConfiguration[serviceName];
            var $enum5 = serviceConfiguration.requiredServices.getEnumerator();
            while ($enum5.moveNext()) {
                var requiredServiceName = $enum5.get_current();
                Framework.AutoWiring._log.debug(String.format('Injecting [{0}] into [{1}]', requiredServiceName, serviceDictionaryEntry.key));
                var requiredService = this._services[requiredServiceName];
                service['set' + Type.getInstanceType(requiredService).get_name()](requiredService);
            }
            Framework.AutoWiring._log.debug(String.format('Subscribing to events {0}', serviceName));
            var $dict6 = serviceConfiguration.connectEvents;
            for (var $key7 in $dict6) {
                var connectedEventsDictionaryEntry = { key: $key7, value: $dict6[$key7] };
                var serviceToConnectTo = this._services[connectedEventsDictionaryEntry.key];
                var events = connectedEventsDictionaryEntry.value;
                if ((events.length === 1) && (!'*'.compareTo(events[0]))) {
                }
                else {
                    var $enum8 = events.getEnumerator();
                    while ($enum8.moveNext()) {
                        var eventName = $enum8.get_current();
                        serviceToConnectTo['register' + eventName + 'Listener'](service);
                    }
                }
            }
        }
    },
    
    getComponentName: function Framework_AutoWiring$getComponentName(placeHolderId, componentClassName) {
        var componentNames = this._componentPlacementMap[placeHolderId];
        var $enum1 = componentNames.getEnumerator();
        while ($enum1.moveNext()) {
            var componentName = $enum1.get_current();
            var config = this.getComponentConfiguration(componentName);
            if (config.className === componentClassName) {
                return componentName;
            }
        }
        return null;
    },
    
    _getComponentPlaceholderId: function Framework_AutoWiring$_getComponentPlaceholderId(componentPlacementMap, componentName) {
        var $dict1 = componentPlacementMap;
        for (var $key2 in $dict1) {
            var placeholderComps = { key: $key2, value: $dict1[$key2] };
            var componentNames = placeholderComps.value;
            var $enum3 = componentNames.getEnumerator();
            while ($enum3.moveNext()) {
                var componentNameItem = $enum3.get_current();
                if (componentNameItem === componentName) {
                    return placeholderComps.key;
                }
            }
        }
        return null;
    },
    
    _initComponents: function Framework_AutoWiring$_initComponents() {
        Framework.AutoWiring._log.debug('InitComponents');
        var $dict1 = this._componentConfiguration;
        for (var $key2 in $dict1) {
            var componentConfigurationDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var componentName = componentConfigurationDictionaryEntry.key;
            this._components[componentName] = Framework.Component.ComponentFactory.create(componentName, componentConfigurationDictionaryEntry.value, this._getComponentPlaceholderId(this._componentPlacementMap, componentName), this._environment);
        }
        var $dict3 = this._components;
        for (var $key4 in $dict3) {
            var componentDictionaryEntry = { key: $key4, value: $dict3[$key4] };
            var componentName = componentDictionaryEntry.key;
            var component = componentDictionaryEntry.value;
            var componentConfigurationItem = this._componentConfiguration[componentName];
            Framework.Component.ComponentFactory.initialize(componentName, component, componentConfigurationItem, this._services, this._components);
        }
    },
    
    _startEnvironment: function Framework_AutoWiring$_startEnvironment() {
        Framework.AutoWiring._log.debug('StartEnvironment');
        this._environment.start();
    },
    
    _startServices: function Framework_AutoWiring$_startServices() {
        Framework.AutoWiring._log.debug('StartServices');
        var $dict1 = this._services;
        for (var $key2 in $dict1) {
            var serviceDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var service = serviceDictionaryEntry.value;
            service.start();
        }
    },
    
    _startTopLevelComponents: function Framework_AutoWiring$_startTopLevelComponents() {
        Framework.AutoWiring._log.debug('StartComponents');
        var $dict1 = this._components;
        for (var $key2 in $dict1) {
            var componentDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var component = componentDictionaryEntry.value;
            if (!component.get_parent()) {
                component.get_componentLifeCycleManager().start();
            }
        }
    },
    
    _startCompleted: false,
    _eventTimeout: 0,
    _safetyTimeout: 0,
    
    run: function Framework_AutoWiring$run() {
        Framework.AutoWiring._log.debug('run');
        this._initEnvironment();
        this._initServices();
        this._initComponents();
        if (ScriptFX.Application.current && !eval('ScriptFX.Application.current._history')) {
            this.runStart();
            return;
        }
        if (ScriptFX.Application.current && ScriptFX.Application.current.get_history().get_isEnabled()) {
            ScriptFX.Application.current.add_load(Delegate.create(this, this.timeOutToRunStart));
            this._safetyTimeout = window.setTimeout(Delegate.create(this, this.runStart), 10 * 1000);
        }
        else {
            this.runStart();
        }
    },
    
    timeOutToRunStart: function Framework_AutoWiring$timeOutToRunStart(sender, args) {
        this._eventTimeout = window.setTimeout(Delegate.create(this, this.runStart), 1);
    },
    
    runStart: function Framework_AutoWiring$runStart() {
        if (!this._startCompleted) {
            window.clearTimeout(this._eventTimeout);
            window.clearTimeout(this._safetyTimeout);
            this._startCompleted = true;
            this._startEnvironment();
            this._startServices();
            this._startTopLevelComponents();
        }
    },
    
    _counter: 0,
    
    addComponent: function Framework_AutoWiring$addComponent(componentNameBase, newComponentConfiguration, placeholderId) {
        if (isNullOrUndefined(this._counter) || !this._counter) {
            this._counter = Object.getKeyCount(this._components) + 1;
        }
        var componentName = String.format('{0}{1}', componentNameBase, this._counter++);
        this._componentConfiguration[componentName] = newComponentConfiguration;
        var componentsForPlaceHolder = this._componentPlacementMap[placeholderId];
        if (!componentsForPlaceHolder) {
            componentsForPlaceHolder = new Array(0);
        }
        var componentsForPlaceHolderAdded = new Array(componentsForPlaceHolder.length + 1);
        for (var i = 0; i < componentsForPlaceHolder.length; i++) {
            componentsForPlaceHolderAdded[i] = componentsForPlaceHolder[i];
        }
        componentsForPlaceHolderAdded[componentsForPlaceHolder.length] = componentName;
        this._componentPlacementMap[placeholderId] = componentsForPlaceHolderAdded;
    },
    
    removeComponent: function Framework_AutoWiring$removeComponent(componentName) {
        var element = this._environment.getDomElement(componentName);
        if (element && element.parentNode) {
            element.parentNode.removeChild(element);
        }
        var placeholderId = this._getComponentPlaceholderId(this._componentPlacementMap, componentName);
        var componentsForPlaceHolder = this._componentPlacementMap[placeholderId];
        var componentsForPlaceHolderArr = [];
        for (var i = 0; i < componentsForPlaceHolder.length; i++) {
            if (componentsForPlaceHolder[i] !== componentName) {
                componentsForPlaceHolderArr.add(componentsForPlaceHolder[i]);
            }
        }
        componentsForPlaceHolder = new Array(componentsForPlaceHolderArr.length);
        for (var i = 0; i < componentsForPlaceHolderArr.length; i++) {
            componentsForPlaceHolder[i] = componentsForPlaceHolderArr[i];
        }
        this._componentPlacementMap[placeholderId] = componentsForPlaceHolder;
        delete this._componentConfiguration[componentName];
        if (!componentsForPlaceHolder.length) {
            this._environment.updateDomElement(placeholderId, '&nbsp;');
        }
    },
    
    updateComponent: function Framework_AutoWiring$updateComponent(componentName, newComponentConfiguration) {
        this._componentConfiguration[componentName] = newComponentConfiguration;
    },
    
    getComponentConfiguration: function Framework_AutoWiring$getComponentConfiguration(componentName) {
        return this._componentConfiguration[componentName];
    },
    
    runForAdmin: function Framework_AutoWiring$runForAdmin() {
        Framework.AutoWiring._log.debug('RunForAdmin');
        this._initEnvironment();
        this._components = {};
        var $dict1 = this._componentConfiguration;
        for (var $key2 in $dict1) {
            var componentConfigurationDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var componentName = componentConfigurationDictionaryEntry.key;
            Framework.AutoWiring._log.debug(String.format('Processing {0}', componentName));
            var componentConfigurationItem = componentConfigurationDictionaryEntry.value;
            var component = eval('new ' + componentConfigurationItem.className + '();');
            this._components[componentName] = component;
            var placeholderId = this._getComponentPlaceholderId(this._componentPlacementMap, componentName);
            if (!this._environment.getDomElement(componentName)) {
                var componentDocumentElement = document.createElement('div');
                componentDocumentElement.className = 'component';
                componentDocumentElement.id = componentName;
                document.getElementById(placeholderId).appendChild(componentDocumentElement);
            }
            component.init(this._environment, String.format('autoWiring.getComponents()[\'{0}\']', componentName), componentName, componentConfigurationItem.parameters);
            component.repaintForAdmin();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.BrowserUtil

Framework.BrowserUtil = function Framework_BrowserUtil() {
}
Framework.BrowserUtil.isMozilla = function Framework_BrowserUtil$isMozilla() {
    return ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.mozilla;
}
Framework.BrowserUtil.isIE = function Framework_BrowserUtil$isIE() {
    return ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE;
}
Framework.BrowserUtil.isOpera = function Framework_BrowserUtil$isOpera() {
    return ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.opera;
}
Framework.BrowserUtil.isSafari = function Framework_BrowserUtil$isSafari() {
    return ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.safari;
}
Framework.BrowserUtil.isFirefox = function Framework_BrowserUtil$isFirefox() {
    var re = new RegExp('Firefox[\\/\\s](\\d+\\.\\d+)');
    return Framework.BrowserUtil.isMozilla() && re.test(window.navigator.userAgent);
}
Framework.BrowserUtil.majorVersion = function Framework_BrowserUtil$majorVersion() {
    return ScriptFX.Application.current.get_host().get_majorVersion();
}
Framework.BrowserUtil.minorVersion = function Framework_BrowserUtil$minorVersion() {
    return ScriptFX.Application.current.get_host().get_minorVersion();
}
Framework.BrowserUtil.isIE5 = function Framework_BrowserUtil$isIE5() {
    return Framework.BrowserUtil.isIE() && (Framework.BrowserUtil.majorVersion() === 5);
}
Framework.BrowserUtil.isIE6 = function Framework_BrowserUtil$isIE6() {
    return Framework.BrowserUtil.isIE() && (Framework.BrowserUtil.majorVersion() === 6);
}
Framework.BrowserUtil.isIE7 = function Framework_BrowserUtil$isIE7() {
    return Framework.BrowserUtil.isIE() && (Framework.BrowserUtil.majorVersion() === 7);
}
Framework.BrowserUtil.isIE8 = function Framework_BrowserUtil$isIE8() {
    return Framework.BrowserUtil.isIE() && (Framework.BrowserUtil.majorVersion() === 8);
}
Framework.BrowserUtil.isIE9 = function Framework_BrowserUtil$isIE9() {
    return Framework.BrowserUtil.isIE() && (Framework.BrowserUtil.majorVersion() === 9);
}
Framework.BrowserUtil.isFirefox1 = function Framework_BrowserUtil$isFirefox1() {
    return Framework.BrowserUtil.isFirefox() && (Framework.BrowserUtil.majorVersion() === 1);
}
Framework.BrowserUtil.isFirefox2 = function Framework_BrowserUtil$isFirefox2() {
    return Framework.BrowserUtil.isFirefox() && (Framework.BrowserUtil.majorVersion() === 2);
}
Framework.BrowserUtil.isFirefox3 = function Framework_BrowserUtil$isFirefox3() {
    return Framework.BrowserUtil.isFirefox() && (Framework.BrowserUtil.majorVersion() === 3);
}
Framework.BrowserUtil.isFirefox4 = function Framework_BrowserUtil$isFirefox4() {
    return Framework.BrowserUtil.isFirefox() && (Framework.BrowserUtil.majorVersion() === 4);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ComponentConfiguration

Framework.ComponentConfiguration = function Framework_ComponentConfiguration(className, childID, requiredServices, parameters, childComponents, connectEvents) {
    this.className = className;
    this.requiredServices = requiredServices;
    this.childID = childID;
    this.parameters = parameters;
    this.connectEvents = connectEvents;
    this.childComponents = childComponents;
}
Framework.ComponentConfiguration.prototype = {
    className: null,
    requiredServices: null,
    childComponents: null,
    childID: null,
    parameters: null,
    connectEvents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.CommonComponentParameters

Framework.CommonComponentParameters = function Framework_CommonComponentParameters(parameters) {
    this._visibleOn = [];
    this._notVisibleOn = [];
    if (!String.isNullOrEmpty(parameters['visible-on'])) {
        this._visibleOn = (parameters['visible-on']).split(',');
    }
    if (!String.isNullOrEmpty(parameters['not-visible-on'])) {
        this._notVisibleOn = (parameters['not-visible-on']).split(',');
    }
    var $enum1 = this._visibleOn.getEnumerator();
    while ($enum1.moveNext()) {
        var i = $enum1.get_current();
        var $enum2 = this._notVisibleOn.getEnumerator();
        while ($enum2.moveNext()) {
            var j = $enum2.get_current();
            if (i === j) {
                throw new Error(String.format('visible-on and not-visible-on cannot contain the same action(s) [{0}]', i));
            }
        }
    }
    this._xsltUrl = parameters['xslt-url'];
    Framework.CommonComponentParameters._log.debug('xsltUrl = [' + this._xsltUrl + ']');
    this._contentUrl = parameters['content-url'];
    Framework.CommonComponentParameters._log.debug('contentUrl = [' + this._contentUrl + ']');
}
Framework.CommonComponentParameters.prototype = {
    
    get_visibleOn: function Framework_CommonComponentParameters$get_visibleOn() {
        return this._visibleOn;
    },
    
    get_notVisibleOn: function Framework_CommonComponentParameters$get_notVisibleOn() {
        return this._notVisibleOn;
    },
    
    _contentUrl: null,
    
    get_contentUrl: function Framework_CommonComponentParameters$get_contentUrl() {
        return this._contentUrl;
    },
    
    _xsltUrl: null,
    
    get_xsltUrl: function Framework_CommonComponentParameters$get_xsltUrl() {
        return this._xsltUrl;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.CookieUtil

Framework.CookieUtil = function Framework_CookieUtil() {
}
Framework.CookieUtil.getCookie = function Framework_CookieUtil$getCookie(name) {
    var cookieName = name + '=';
    var documentCookie = document.cookie.split(';');
    for (var i = 0; i < documentCookie.length; i++) {
        var index = documentCookie[i];
        while (index.charAt(0) === ' ') {
            index = index.substring(1, index.length);
        }
        if (!index.indexOf(cookieName)) {
            return unescape(index.substring(cookieName.length, index.length));
        }
    }
    return null;
}
Framework.CookieUtil.setCookie = function Framework_CookieUtil$setCookie(name, value) {
    document.cookie = String.format('{0}={1}; expires={2}; path=/', name, escape(value), Framework.CookieUtil.getDateTime(365));
}
Framework.CookieUtil.setCookieWithDays = function Framework_CookieUtil$setCookieWithDays(name, value, numberOfDays) {
    document.cookie = String.format('{0}={1}; expires={2}; path=/', name, escape(value), Framework.CookieUtil.getDateTime(numberOfDays));
}
Framework.CookieUtil.clearCookie = function Framework_CookieUtil$clearCookie(name) {
    Framework.CookieUtil.setCookieWithDays(name, '', -1);
}
Framework.CookieUtil.clearCookies = function Framework_CookieUtil$clearCookies() {
    var allCookies = document.cookie.split(';');
    for (var i = 0; i < allCookies.length; i++) {
        var currentCookie = allCookies[i].split('=');
        if (currentCookie[0]) {
            Framework.CookieUtil.setCookieWithDays(currentCookie[0], '', -1);
        }
    }
}
Framework.CookieUtil.getDateTime = function Framework_CookieUtil$getDateTime(numberOfDays) {
    var dt = new Date();
    dt.setTime(dt.getTime() + numberOfDays * 86400000);
    return dt.toUTCString();
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AjaxUpdater

Framework.AjaxUpdater = function Framework_AjaxUpdater(domElementId, url, afterUpdateCallback, afterErrorCallback) {
    this._domElementId = domElementId;
    this._url = url;
    this._afterUpdateCallback = afterUpdateCallback;
    this._afterErrorCallback = afterErrorCallback;
}
Framework.AjaxUpdater.prototype = {
    _domElementId: null,
    _url: null,
    _request: null,
    _afterUpdateCallback: null,
    _afterErrorCallback: null,
    evalScripts: false,
    _scripts: null,
    
    _extractScripts: function Framework_AjaxUpdater$_extractScripts(responseText) {
        var regex = new RegExp(Framework.AjaxUpdater._scriptregex, 'img');
        var regexInner = new RegExp(Framework.AjaxUpdater._scriptregex, 'im');
        var scriptBlocks = responseText.match(regex);
        if (!scriptBlocks) {
            return new Array(0);
        }
        var scripts = new Array(scriptBlocks.length);
        for (var i = 0; i < scriptBlocks.length; i++) {
            var scriptBlockParts = scriptBlocks[i].match(regexInner);
            if (!scriptBlockParts || !scriptBlockParts.length) {
                scripts[i] = '';
            }
            else {
                scripts[i] = scriptBlockParts[scriptBlockParts.length - 1];
            }
        }
        return scripts;
    },
    
    executeScripts: function Framework_AjaxUpdater$executeScripts() {
        var $enum1 = this._scripts.getEnumerator();
        while ($enum1.moveNext()) {
            var script = $enum1.get_current();
            if (!String.isNullOrEmpty(script)) {
                eval(script);
            }
        }
    },
    
    update: function Framework_AjaxUpdater$update() {
        if (!this._url && this._afterErrorCallback) {
            this._afterErrorCallback.invoke();
            return;
        }
        this._request = new Framework.XMLHttpRequestDecorator();
        this._request.onreadystatechange = Delegate.create(this, function() {
            if (this._request.readyState === 4) {
                if (this._request.status === 200 || this._request.status === 304) {
                    Framework.AbstractEnvironment.safeUpdateDomElement(this._domElementId, this._request.responseText);
                    if (this.evalScripts) {
                        this._scripts = this._extractScripts(this._request.responseText);
                        window.setTimeout(Delegate.create(this, this.executeScripts), 10);
                        this.executeScripts();
                    }
                    if (this._afterUpdateCallback) {
                        this._afterUpdateCallback.invoke();
                    }
                }
                else if (this._afterErrorCallback) {
                    this._afterErrorCallback.invoke();
                }
            }
        });
        this._request.open('GET', this._url, true);
        this._request.send(null);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.AbstractMessagingService

Framework.AbstractMessagingService = function Framework_AbstractMessagingService() {
    this._topics$1 = {};
    this._topicChangedListeners$1 = {};
    Framework.AbstractMessagingService.constructBase(this);
}
Framework.AbstractMessagingService.prototype = {
    
    registerTopicChangedListener: function Framework_AbstractMessagingService$registerTopicChangedListener(topicChangedListener, topic) {
        Framework.AbstractMessagingService._log$1.debug(String.format('RegisterTopicChangedListener topic=[{0}]', topic));
        if (!Object.keyExists(this._topicChangedListeners$1, topic)) {
            this._topicChangedListeners$1[topic] = [];
        }
        if (!(this._topicChangedListeners$1[topic]).contains(topicChangedListener)) {
            (this._topicChangedListeners$1[topic]).add(topicChangedListener);
        }
    },
    
    _fireTopicChangedEvent$1: function Framework_AbstractMessagingService$_fireTopicChangedEvent$1(listeners) {
        Framework.AbstractMessagingService._log$1.debug('FireTopicChangedEvent');
        var $enum1 = listeners.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onTopicChanged(this);
            }
            catch (e) {
                Framework.AbstractMessagingService._log$1.error('FireTopicChangedEvent OnTopicChanged', e);
            }
        }
    },
    
    getAllTopics: function Framework_AbstractMessagingService$getAllTopics() {
        var result = {};
        var $dict1 = this._topics$1;
        for (var $key2 in $dict1) {
            var de = { key: $key2, value: $dict1[$key2] };
            result[de.key] = de.value;
        }
        return result;
    },
    
    setAllTopics: function Framework_AbstractMessagingService$setAllTopics(topics) {
        var changedTopics = [];
        var $dict1 = this._topics$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (!Object.keyExists(topics, entry.key) || topics[entry.key] !== entry.value) {
                changedTopics.add(entry.key);
            }
        }
        var $dict3 = topics;
        for (var $key4 in $dict3) {
            var entry = { key: $key4, value: $dict3[$key4] };
            if (!changedTopics.contains(entry.key) && (!Object.keyExists(this._topics$1, entry.key) || this._topics$1[entry.key] !== entry.value)) {
                changedTopics.add(entry.key);
            }
        }
        var listeners = [];
        for (var i = 0; i < changedTopics.length; i++) {
            var topicListeners = [];
            if (Object.keyExists(this._topicChangedListeners$1, changedTopics[i])) {
                topicListeners = this._topicChangedListeners$1[changedTopics[i]];
            }
            for (var j = 0; j < topicListeners.length; j++) {
                if (!listeners.contains(topicListeners[j])) {
                    listeners.add(topicListeners[j]);
                }
            }
        }
        if (changedTopics.length > 0) {
            this._topics$1 = topics;
            this._fireTopicChangedEvent$1(listeners);
        }
    },
    
    getTopic: function Framework_AbstractMessagingService$getTopic(topic) {
        return this._topics$1[topic];
    },
    
    setTopic: function Framework_AbstractMessagingService$setTopic(topic, value) {
        if (String.compare(value, this._topics$1[topic])) {
            this._topics$1[topic] = value;
            var listeners = this._topicChangedListeners$1[topic];
            if (listeners) {
                this._fireTopicChangedEvent$1(listeners);
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DynamicComponentConfiguration

Framework.DynamicComponentConfiguration = function Framework_DynamicComponentConfiguration(requiredServices, parameters, connectEvents) {
    this.requiredServices = requiredServices;
    this.parameters = parameters;
    this.connectEvents = connectEvents;
}
Framework.DynamicComponentConfiguration.prototype = {
    requiredServices: null,
    parameters: null,
    connectEvents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.CustomCultureInfo

Framework.CustomCultureInfo = function Framework_CustomCultureInfo() {
}
Framework.CustomCultureInfo.add = function Framework_CustomCultureInfo$add(cultureKey, customCultureInfo) {
    Framework.CustomCultureInfo._customCultures[cultureKey] = customCultureInfo;
}
Framework.CustomCultureInfo.getCustomCultures = function Framework_CustomCultureInfo$getCustomCultures() {
    return Framework.CustomCultureInfo._customCultures;
}
Framework.CustomCultureInfo.addRegionDefaultCulture = function Framework_CustomCultureInfo$addRegionDefaultCulture(region, cultureKey) {
    Framework.CustomCultureInfo._regionalDefaultCulture[region + '_'] = cultureKey;
}
Framework.CustomCultureInfo.addLanguageDefaultCulture = function Framework_CustomCultureInfo$addLanguageDefaultCulture(language, cultureKey) {
    Framework.CustomCultureInfo._regionalDefaultCulture['_' + language] = cultureKey;
}
Framework.CustomCultureInfo.addRegionLanguageDefaultCulture = function Framework_CustomCultureInfo$addRegionLanguageDefaultCulture(region, language, cultureKey) {
    Framework.CustomCultureInfo._regionalDefaultCulture[region + '_' + language] = cultureKey;
}
Framework.CustomCultureInfo.getRegionalCultureKey = function Framework_CustomCultureInfo$getRegionalCultureKey(region, language) {
    if (Object.keyExists(Framework.CustomCultureInfo._regionalDefaultCulture, region + '_' + language)) {
        return Framework.CustomCultureInfo._regionalDefaultCulture[region + '_' + language];
    }
    else if (Object.keyExists(Framework.CustomCultureInfo._regionalDefaultCulture, '_' + language)) {
        return Framework.CustomCultureInfo._regionalDefaultCulture['_' + language];
    }
    else if (Object.keyExists(Framework.CustomCultureInfo._regionalDefaultCulture, region + '_')) {
        return Framework.CustomCultureInfo._regionalDefaultCulture[region + '_'];
    }
    else {
        return '';
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.NavigationTypeGroup

Framework.NavigationTypeGroup = function Framework_NavigationTypeGroup(matchingGroup) {
    this.matchingGroup = matchingGroup;
}
Framework.NavigationTypeGroup.prototype = {
    matchingGroup: null,
    
    isMatch: function Framework_NavigationTypeGroup$isMatch(navigationTypes) {
        if (!navigationTypes) {
            return false;
        }
        if (!this.matchingGroup) {
            return false;
        }
        if (navigationTypes.length !== this.matchingGroup.length) {
            return false;
        }
        for (var count = 0; count < navigationTypes.length; count++) {
            if (!navigationTypes.contains(this.matchingGroup[count])) {
                return false;
            }
        }
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.StringHelper

Framework.StringHelper = function Framework_StringHelper() {
}
Framework.StringHelper.fromCharCode = function Framework_StringHelper$fromCharCode(charCode) {
    return String.fromCharCode(charCode);
}
Framework.StringHelper.equals = function Framework_StringHelper$equals(s1, s2, ignoreCase) {
    return String.equals(s1, s2, ignoreCase);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ListenerInvoker

Framework.ListenerInvoker = function Framework_ListenerInvoker(isAsync) {
    this._listeners = [];
    this._isAsync = isAsync;
}
Framework.ListenerInvoker.prototype = {
    _isAsync: true,
    
    registerListener: function Framework_ListenerInvoker$registerListener(listener) {
        if (!this._listeners.contains(listener)) {
            this._listeners.add(listener);
        }
    },
    
    unregisterListener: function Framework_ListenerInvoker$unregisterListener(listener) {
        this._listeners.remove(listener);
    },
    
    _createDelegate: function Framework_ListenerInvoker$_createDelegate(listenerCallback, i) {
        return Delegate.create(this, function() {
            listenerCallback.invoke(this._listeners[i]);
        });
    },
    
    fireUpdateEvent: function Framework_ListenerInvoker$fireUpdateEvent(listenerCallback) {
        for (var i = 0; i < this._listeners.length; i++) {
            if (this._isAsync) {
                window.setTimeout(this._createDelegate(listenerCallback, i), 0);
            }
            else {
                try {
                    listenerCallback.invoke(this._listeners[i]);
                }
                catch (ex) {
                    Framework.ListenerInvoker._log.error('FireUpdateEvent', ex);
                }
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Parameters

Framework.Parameters = function Framework_Parameters() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragEventArgs

Framework.DragEventArgs = function Framework_DragEventArgs() {
}
Framework.DragEventArgs.prototype = {
    offsetX: null,
    offsetY: null,
    layerX: null,
    layerY: null,
    clientX: null,
    clientY: null,
    srcElement: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragObjectPosition

Framework.DragObjectPosition = function Framework_DragObjectPosition(position, zIndex, clientLeft, clientTop) {
    this.position = position;
    this.zIndex = zIndex;
    this.clientLeft = clientLeft;
    this.clientTop = clientTop;
}
Framework.DragObjectPosition.prototype = {
    position: null,
    zIndex: 0,
    clientLeft: null,
    clientTop: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragArgs

Framework.DragArgs = function Framework_DragArgs() {
}
Framework.DragArgs.prototype = {
    dragsRefresh: null,
    dropClassName: null,
    dragClassName: null,
    dropHoverClassName: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Droppables

Framework.Droppables = function Framework_Droppables() {
}
Framework.Droppables.add = function Framework_Droppables$add(element) {
    Framework.Droppables.drops.add(element);
}
Framework.Droppables.getDroppable = function Framework_Droppables$getDroppable(x, y) {
    x += Framework.Droppables.offsetLocation.left;
    y += Framework.Droppables.offsetLocation.top;
    var $enum1 = Framework.Droppables.drops.getEnumerator();
    while ($enum1.moveNext()) {
        var drop = $enum1.get_current();
        var bounds = ScriptFX.UI.Element.getBounds(drop);
        if (drop.style && drop.style.position === 'relative') {
            drop.style.position = 'absolute';
            bounds = ScriptFX.UI.Element.getBounds(drop);
            drop.style.position = 'relative';
        }
        if (y >= bounds.top && y <= (bounds.top + bounds.height)) {
            if (x >= bounds.left && x <= (bounds.left + bounds.width)) {
                return drop;
            }
        }
    }
    return null;
}
Framework.Droppables.setOffset = function Framework_Droppables$setOffset(x, y) {
    Framework.Droppables.offsetLocation.top = y;
    Framework.Droppables.offsetLocation.left = x;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DraggableStartLocations

Framework.DraggableStartLocations = function Framework_DraggableStartLocations() {
}
Framework.DraggableStartLocations.add = function Framework_DraggableStartLocations$add(element) {
    Framework.DraggableStartLocations._dictionary[element.id] = ScriptFX.UI.Element.getLocation(element);
}
Framework.DraggableStartLocations.get = function Framework_DraggableStartLocations$get(element) {
    var key = element.id;
    if (Object.keyExists(Framework.DraggableStartLocations._dictionary, key)) {
        return Framework.DraggableStartLocations._dictionary[key];
    }
    return null;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragableControl

Framework.DragableControl = function Framework_DragableControl() {
    Framework.DragableControl.constructBase(this);
}
Framework.DragableControl.resetLocation = function Framework_DragableControl$resetLocation(element) {
    var location = Framework.DraggableStartLocations.get(element);
    if (location) {
        ScriptFX.UI.Element.setLocation(element, location);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Position

Framework.Position = function Framework_Position(x, y) {
    this.x = x;
    this.y = y;
}
Framework.Position.prototype = {
    x: 0,
    y: 0,
    scrollX: 0,
    scrollY: 0,
    
    prepare: function Framework_Position$prepare() {
        if (!isNullOrUndefined(document.documentElement.scrollLeft) && document.documentElement.scrollLeft) {
            this.scrollX = document.documentElement.scrollLeft;
        }
        else if (!isNullOrUndefined(document.body.scrollLeft) && document.body.scrollLeft) {
            this.scrollX = document.documentElement.scrollLeft;
        }
        if (!isNullOrUndefined(document.documentElement.scrollLeft) && document.documentElement.scrollTop) {
            this.scrollY = document.documentElement.scrollTop;
        }
        else if (!isNullOrUndefined(document.body.scrollLeft) && document.body.scrollTop) {
            this.scrollY = document.documentElement.scrollTop;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DragController

Framework.DragController = function Framework_DragController(o, oRoot, minX, maxX, minY, maxY, bSwapHorzRef, bSwapVertRef, fXMapper, fYMapper) {
    this.obj = o;
    o.onmousedown = Delegate.create(this, this.start);
    o.hmode = (bSwapHorzRef) ? false : true;
    o.vmode = (bSwapVertRef) ? false : true;
    o.minX = (isNaN(minX)) ? null : minX;
    o.minY = (isNaN(minY)) ? null : minY;
    o.maxX = (isNaN(maxX)) ? null : maxX;
    o.maxY = (isNaN(maxY)) ? null : maxY;
    o.xMapper = fXMapper;
    o.yMapper = fYMapper;
    o.root = (oRoot) ? oRoot : o;
    if (o.hmode && isNaN(parseInt(o.root.style.left))) {
        o.root.style.left = '0px';
    }
    if (o.vmode && isNaN(parseInt(o.root.style.top))) {
        o.root.style.top = '0px';
    }
    if (!o.hmode && isNaN(parseInt(o.root.style.right))) {
        o.root.style.right = '0px';
    }
    if (!o.vmode && isNaN(parseInt(o.root.style.bottom))) {
        o.root.style.bottom = '0px';
    }
    o.root.style.zIndex = 9999;
    o.root.onDragStart = Delegate.create(this, function(e) {
        return false;
    });
    o.root.onDragEnd = Delegate.create(this, function(obj, x, y) {
    });
    o.root.onDrag = Delegate.create(this, function(obj, x, y) {
    });
    this.dragHandler = Framework.DocumentEvents.parse(Delegate.create(this, this.dragHandle));
    this.endHandler = Framework.DocumentEvents.parse(Delegate.create(this, this.endHandle));
}
Framework.DragController.getAbsolutePosition = function Framework_DragController$getAbsolutePosition(element) {
    var pos = new Framework.Position(element.offsetLeft, element.offsetTop);
    if (element.offsetParent) {
        var parentPos = Framework.DragController.getAbsolutePosition(element.offsetParent);
        pos.x += parentPos.x;
        pos.y += parentPos.y;
    }
    return pos;
}
Framework.DragController.absolutize = function Framework_DragController$absolutize(element) {
    if (element.style.position === 'absolute') {
        return;
    }
    var pos = Framework.DragController.getAbsolutePosition(element);
    element.style.position = 'absolute';
    element.style.left = (pos.x - element.clientLeft) + 'px';
    element.style.top = (pos.y - element.clientTop) + 'px';
}
Framework.DragController.prototype = {
    obj: null,
    _initialPosition: null,
    
    startHandle: function Framework_DragController$startHandle() {
        this.start(this._getWindowEvent());
    },
    
    start: function Framework_DragController$start(e) {
        e = this.fixE(e);
        var o = this.obj;
        this._initialPosition = new Framework.DragObjectPosition(o.style.position, o.style.zIndex, o.clientLeft, o.clientTop);
        var y = parseInt((o.vmode) ? o.root.style.top : o.root.style.bottom);
        var x = parseInt((o.hmode) ? o.root.style.left : o.root.style.right);
        o.lastMouseX = e.clientX;
        o.lastMouseY = e.clientY;
        o.offsetX = e.clientX;
        o.offsetY = e.clientY;
        o.root.onDragStart.invoke(e);
        if (o.hmode) {
            if (o.minX) {
                o.minMouseX = e.clientX - x + o.minX;
            }
            if (o.maxX) {
                o.maxMouseX = o.minMouseX + o.maxX - o.minX;
            }
        }
        else {
            if (o.minX) {
                o.maxMouseX = -o.minX + e.clientX + x;
            }
            if (o.maxX) {
                o.minMouseX = -o.maxX + e.clientX + x;
            }
        }
        if (o.vmode) {
            if (o.minY) {
                o.minMouseY = e.clientY - y + o.minY;
            }
            if (o.maxY) {
                o.maxMouseY = o.minMouseY + o.maxY - o.minY;
            }
        }
        else {
            if (o.minY) {
                o.maxMouseY = -o.minY + e.clientY + y;
            }
            if (o.maxY) {
                o.minMouseY = -o.maxY + e.clientY + y;
            }
        }
        Framework.DocumentEvents.setOnMousemove(null);
        Framework.DocumentEvents.setOnMouseup(null);
        document.attachEvent('onmousemove', this.dragHandler);
        document.attachEvent('onmouseup', this.endHandler);
        if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
            window.event.cancelBubble = true;
        }
        else {
            Framework.BubblingEvent.parse(window.event).stopPropagation();
        }
        return false;
    },
    
    dragHandle: function Framework_DragController$dragHandle() {
        return this.drag(this._getWindowEvent());
    },
    
    drag: function Framework_DragController$drag(e) {
        e = this.fixE(e);
        var o = this.obj;
        var ey = e.clientY;
        var ex = e.clientX;
        var y = parseInt((o.vmode) ? o.root.style.top : o.root.style.bottom);
        var x = parseInt((o.hmode) ? o.root.style.left : o.root.style.right);
        var nx;
        var ny;
        if (o.minX) {
            ex = (o.hmode) ? Math.max(ex, o.minMouseX) : Math.min(ex, o.maxMouseX);
        }
        if (o.maxX) {
            ex = (o.hmode) ? Math.min(ex, o.maxMouseX) : Math.max(ex, o.minMouseX);
        }
        if (o.minY) {
            ey = (o.vmode) ? Math.max(ey, o.minMouseY) : Math.min(ey, o.maxMouseY);
        }
        if (o.maxY) {
            ey = (o.vmode) ? Math.min(ey, o.maxMouseY) : Math.max(ey, o.minMouseY);
        }
        nx = x + ((ex - o.lastMouseX) * ((o.hmode) ? 1 : -1));
        ny = y + ((ey - o.lastMouseY) * ((o.vmode) ? 1 : -1));
        if (o.xMapper) {
            nx = o.xMapper.invoke(x);
        }
        if (o.yMapper) {
            ny = o.yMapper.invoke(y);
        }
        if (o.hmode) {
            this.obj.root.style.left = nx + 'px';
        }
        else {
            this.obj.root.style.right = nx + 'px';
        }
        if (o.vmode) {
            this.obj.root.style.top = ny + 'px';
        }
        else {
            this.obj.root.style.bottom = ny + 'px';
        }
        this.obj.lastMouseX = ex;
        this.obj.lastMouseY = ey;
        this.obj.root.onDrag.invoke(this.obj, nx, ny);
        if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
            window.event.cancelBubble = true;
        }
        else {
            Framework.BubblingEvent.parse(window.event).stopPropagation();
        }
        return false;
    },
    
    endHandle: function Framework_DragController$endHandle() {
        return this.end(this._getWindowEvent());
    },
    
    end: function Framework_DragController$end(e) {
        document.detachEvent('onmousemove', this.dragHandler);
        document.detachEvent('onmouseup', this.endHandler);
        var style = this.obj.root.style;
        var x = parseInt((this.obj.hmode) ? style.left : style.right);
        var y = parseInt((this.obj.vmode) ? style.top : style.bottom);
        this.obj.root.onDragEnd.invoke(this.obj, x, y);
        return false;
    },
    
    fixE: function Framework_DragController$fixE(evt) {
        if (!evt) {
            evt = this._getWindowEvent();
        }
        return evt;
    },
    
    dragHandler: null,
    endHandler: null,
    
    _getWindowEvent: function Framework_DragController$_getWindowEvent() {
        var o = window.event;
        return o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Logger

Framework.Logger = function Framework_Logger() {
}
Framework.Logger.isLoggingEnabled = function Framework_Logger$isLoggingEnabled() {
    return Framework.Logger._isLoggingEnabled;
}
Framework.Logger.switchLogging = function Framework_Logger$switchLogging() {
    Framework.Logger._isLoggingEnabled = !Framework.Logger._isLoggingEnabled;
}
Framework.Logger.getLog = function Framework_Logger$getLog(typeName) {
    return new Framework.Log(typeName);
}
Framework.Logger.setMaximumLogSize = function Framework_Logger$setMaximumLogSize(maximumLogSize) {
    Framework.Logger._maximumLogSize = maximumLogSize;
}
Framework.Logger.getMaximumLogSize = function Framework_Logger$getMaximumLogSize() {
    return Framework.Logger._maximumLogSize;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.JSONFormat

Framework.JSONFormat = function Framework_JSONFormat() {
}
Framework.JSONFormat.formatDateTime = function Framework_JSONFormat$formatDateTime(dateTime) {
    return ((!dateTime) ? null : String.format('{0}-{1}-{2} {3}-{4}-{5}', dateTime.getDate(), dateTime.getMonth() + 1, dateTime.getFullYear(), dateTime.getHours(), dateTime.getMinutes(), dateTime.getSeconds()));
}
Framework.JSONFormat.parseDateTime = function Framework_JSONFormat$parseDateTime(dateTime) {
    var dateTimeParts = dateTime.split(new RegExp('[- ]'));
    return new Date(Number.parse(dateTimeParts[2]), Number.parse(dateTimeParts[1]) - 1, Number.parse(dateTimeParts[0]), Number.parse(dateTimeParts[3]), Number.parse(dateTimeParts[4]), Number.parse(dateTimeParts[5]));
}


////////////////////////////////////////////////////////////////////////////////
// Framework.JsonRpcTask

Framework.JsonRpcTask = function Framework_JsonRpcTask(serviceName, methodName, IDMDLanguage, arguments, jsonRpcSuccessCallback, jsonRpcFailureCallback) {
    arguments['IDMDLanguage'] = IDMDLanguage;
    this._requestPayload = { serviceName: serviceName, methodName: methodName, arguments: arguments };
    this._jsonRpcSuccessCallback = jsonRpcSuccessCallback;
    this._jsonRpcFailureCallback = jsonRpcFailureCallback;
    this._sdcToken = Framework.SDC.SDCManager.sdcManagerInstance().startRPCLog(serviceName, methodName);
}
Framework.JsonRpcTask.prototype = {
    _requestPayload: null,
    _jsonRpcSuccessCallback: null,
    _jsonRpcFailureCallback: null,
    _sdcToken: null,
    
    get_jsonRpcSuccessCallback: function Framework_JsonRpcTask$get_jsonRpcSuccessCallback() {
        return this._jsonRpcSuccessCallback;
    },
    
    get_jsonRpcFailureCallback: function Framework_JsonRpcTask$get_jsonRpcFailureCallback() {
        return this._jsonRpcFailureCallback;
    },
    
    getRequestPayload: function Framework_JsonRpcTask$getRequestPayload() {
        return Framework.JsonUtil.serialize(this._requestPayload);
    },
    
    getPayloadAsDictionary: function Framework_JsonRpcTask$getPayloadAsDictionary() {
        return this._requestPayload;
    },
    
    getSDCToken: function Framework_JsonRpcTask$getSDCToken() {
        return this._sdcToken;
    },
    
    processResponse: function Framework_JsonRpcTask$processResponse(httpResponse) {
        if (httpResponse) {
            if (httpResponse.get_statusCode() === ScriptFX.Net.HTTPStatusCode.OK) {
                var response = Framework.JsonUtil.deserialize(httpResponse.getText());
                var exceptionType = null;
                var message = null;
                if (response['exceptionType']) {
                    exceptionType = response['exceptionType'];
                }
                if (response['message']) {
                    message = response['message'].toString();
                }
                Framework.SDC.SDCManager.sdcManagerInstance().endRPCLog(this._sdcToken, response['token'], (String.isNullOrEmpty(exceptionType)) ? Framework.SDC.SDCExceptionType.noException : Framework.SDC.SDCExceptionType.callbrokerRPCException);
                if (!String.isNullOrEmpty(exceptionType)) {
                    this._jsonRpcFailureCallback.invoke(Framework.ExceptionUtil.createException(exceptionType, message));
                }
                else {
                    this._jsonRpcSuccessCallback.invoke(response['result']);
                }
            }
            else if (httpResponse.get_statusCode() === ScriptFX.Net.HTTPStatusCode.internalServerError) {
                var response = Framework.JsonUtil.deserialize(httpResponse.getText());
                var exceptionType = null;
                var message = null;
                if (response['exceptionType']) {
                    exceptionType = response['exceptionType'];
                }
                if (response['message']) {
                    message = response['message'];
                }
                Framework.SDC.SDCManager.sdcManagerInstance().endRPCLog(this._sdcToken, response['token'], Framework.SDC.SDCExceptionType.operationalException);
                this._jsonRpcFailureCallback.invoke(Framework.ExceptionUtil.createException(exceptionType, message));
            }
            else {
                Framework.SDC.SDCManager.sdcManagerInstance().endRPCLog(this._sdcToken, '', Framework.SDC.SDCExceptionType.operationalException);
                this._jsonRpcFailureCallback.invoke(Framework.ExceptionUtil.createException('RemoteException', null));
            }
        }
        else {
            Framework.SDC.SDCManager.sdcManagerInstance().abortRPCLog(this._sdcToken);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ExceptionDetails

Framework.ExceptionDetails = function Framework_ExceptionDetails(exceptionType, message) {
    this._exceptionType = exceptionType;
    if (this._exceptionType === 'System.FormatException') {
        this._message = 'A required field is not filled in.';
    }
    else {
        this._message = message;
    }
    if (!this._message) {
        this._message = 'Please contact customer support';
    }
}
Framework.ExceptionDetails.prototype = {
    _exceptionType: null,
    
    get_exceptionType: function Framework_ExceptionDetails$get_exceptionType() {
        return this._exceptionType;
    },
    
    _message: null,
    
    get_message: function Framework_ExceptionDetails$get_message() {
        return this._message;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ExceptionTypes

Framework.ExceptionTypes = function Framework_ExceptionTypes() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ExceptionUtil

Framework.ExceptionUtil = function Framework_ExceptionUtil() {
}
Framework.ExceptionUtil.createException = function Framework_ExceptionUtil$createException(exceptionType, message) {
    return new Error(String.format('{0}{1}{2}', exceptionType, Framework.ExceptionUtil._separator, (String.isNullOrEmpty(message)) ? String.Empty : message));
}
Framework.ExceptionUtil.getExceptionDetails = function Framework_ExceptionUtil$getExceptionDetails(exception) {
    Framework.ExceptionUtil._log.debug(String.format('GetExceptionDetails exception=[{0}]', Framework.DictionaryUtil.dumpObjectToString(exception)));
    var messageTokens = exception.message.split(Framework.ExceptionUtil._separator);
    return new Framework.ExceptionDetails(messageTokens[0], messageTokens[1]);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Log

Framework.Log = function Framework_Log(typeName) {
    this._typeName = typeName;
}
Framework.Log.prototype = {
    _typeName: null,
    
    _write: function Framework_Log$_write(message) {
        if (!Framework.Logger.isLoggingEnabled()) {
            return;
        }
        if (!Framework.Log._domElementName) {
            return;
        }
        var _domElement = document.getElementById(Framework.Log._domElementName);
        if (!_domElement) {
            return;
        }
        var maximumLogSize = Framework.Logger.getMaximumLogSize();
        if (maximumLogSize > 0 && _domElement.innerHTML.length > maximumLogSize) {
            Framework.AbstractEnvironment.safeUpdateDomElementDirect(_domElement, '');
        }
        var newElement = document.createElement('span');
        newElement.innerText = this._prefixMessageWithTypeName(message);
        _domElement.appendChild(newElement);
    },
    
    _prefixMessageWithTypeName: function Framework_Log$_prefixMessageWithTypeName(message) {
        return String.format('{0}.{1}', this._typeName, message);
    },
    
    debug: function Framework_Log$debug(message) {
        this._write(message + '<br />\n');
    },
    
    error: function Framework_Log$error(message, exception) {
        this._write('<span style=\'color: red\'>' + this._prefixMessageWithTypeName(message) + ':' + Framework.ExceptionUtil.getExceptionDetails(exception).get_message() + '</span><br />\n');
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.RemoteException

Framework.RemoteException = function Framework_RemoteException() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ServiceConfiguration

Framework.ServiceConfiguration = function Framework_ServiceConfiguration(className, requiredServices, parameters, connectEvents) {
    this.className = className;
    this.requiredServices = requiredServices;
    this.parameters = parameters;
    this.connectEvents = connectEvents;
}
Framework.ServiceConfiguration.prototype = {
    className: null,
    requiredServices: null,
    parameters: null,
    connectEvents: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.FormUtil

Framework.FormUtil = function Framework_FormUtil() {
}
Framework.FormUtil._purgePrefix = function Framework_FormUtil$_purgePrefix(id, idElementPrefix) {
    var oCharacters = [ 9, 10, 13, 32 ];
    var i = 0;
    var idReplaced;
    idReplaced = id;
    for (i = 0; i < oCharacters.length; i++) {
        idReplaced = idReplaced.replace(String.fromCharCode(oCharacters[i]), '');
    }
    return idReplaced.substr(idElementPrefix.length);
}
Framework.FormUtil.getFormAsDictionary = function Framework_FormUtil$getFormAsDictionary(formId, idElementPrefix) {
    var result = {};
    var formElement = document.getElementById(formId);
    var domElementCollection = formElement.getElementsByTagName('input');
    for (var i = 0; i < domElementCollection.length; i++) {
        var inputElement = domElementCollection[i];
        if (inputElement.id && inputElement.id.startsWith(idElementPrefix)) {
            if (!'radio'.compareTo(inputElement.type, true)) {
                if ((inputElement).checked && !String.isNullOrEmpty(inputElement.getAttribute('name'))) {
                    result[Framework.FormUtil._purgePrefix(inputElement.getAttribute('name'), idElementPrefix)] = inputElement.value;
                }
            }
            else if (!'checkbox'.compareTo(inputElement.type, true)) {
                result[Framework.FormUtil._purgePrefix(inputElement.id, idElementPrefix)] = (inputElement).checked;
            }
            else {
                result[Framework.FormUtil._purgePrefix(inputElement.id, idElementPrefix)] = inputElement.value;
            }
        }
    }
    domElementCollection = formElement.getElementsByTagName('select');
    for (var i = 0; i < domElementCollection.length; i++) {
        var selectElement = domElementCollection[i];
        if (selectElement.id && selectElement.id.startsWith(idElementPrefix)) {
            result[Framework.FormUtil._purgePrefix(selectElement.id, idElementPrefix)] = selectElement.value;
        }
    }
    domElementCollection = formElement.getElementsByTagName('textarea');
    for (var i = 0; i < domElementCollection.length; i++) {
        var textAreaElement = domElementCollection[i];
        if (textAreaElement.id && textAreaElement.id.startsWith(idElementPrefix)) {
            result[Framework.FormUtil._purgePrefix(textAreaElement.id, idElementPrefix)] = textAreaElement.value;
        }
    }
    return result;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DictionaryUtil

Framework.DictionaryUtil = function Framework_DictionaryUtil() {
}
Framework.DictionaryUtil.equal = function Framework_DictionaryUtil$equal(first, second) {
    if (!first && !second) {
        return true;
    }
    if (!first && second) {
        return false;
    }
    if (first && !second) {
        return false;
    }
    if (Object.getKeyCount(first) !== Object.getKeyCount(second)) {
        return false;
    }
    var $dict1 = first;
    for (var $key2 in $dict1) {
        var de = { key: $key2, value: $dict1[$key2] };
        var key = de.key;
        if (!Object.keyExists(second, key)) {
            return false;
        }
        var firstval = de.value;
        var secondval = second[key];
        if (!firstval && !secondval) {
            continue;
        }
        if (!firstval && secondval) {
            return false;
        }
        if (firstval && !secondval) {
            return false;
        }
        if (firstval !== secondval) {
            return false;
        }
    }
    return true;
}
Framework.DictionaryUtil.dumpToString = function Framework_DictionaryUtil$dumpToString(dictionary) {
    var result = '{';
    var $dict1 = dictionary;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        if (entry.key) {
            result += String.format('{0}:{1}; ', entry.key, entry.value);
        }
    }
    return result + '}';
}
Framework.DictionaryUtil.dumpObjectToString = function Framework_DictionaryUtil$dumpObjectToString(obj) {
    return Framework.DictionaryUtil.dumpToString(obj);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.ToolTipBehavior

Framework.ToolTipBehavior = function Framework_ToolTipBehavior(domElement, id) {
    Framework.ToolTipBehavior.constructBase(this, [ domElement, id ]);
    this.get_domEvents().attach('ommousemove', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var toolTips = document.getElementsByTagName('span');
        for (var i = 0; i < toolTips.length; i++) {
            if (toolTips[i].className === 'tip-info') {
                var ttleftOffset = 10;
                var tttopOffset = 15;
                var leftPos = window.event.offsetX;
                var topPos = window.event.offsetY;
                var absoluteLeftPos = 0;
                var absoluteTopPos = 0;
                var offsetParent = srcElement;
                while (offsetParent) {
                    absoluteLeftPos += offsetParent.offsetLeft;
                    absoluteTopPos += offsetParent.offsetTop;
                    offsetParent = offsetParent.offsetParent;
                }
                leftPos += absoluteLeftPos;
                topPos += absoluteTopPos;
                var screenWidth = window.document.body.offsetWidth;
                var screenHeight = window.document.body.offsetHeight;
                if ((screenWidth - absoluteLeftPos) < (150 + ttleftOffset)) {
                    var newLeftPos = leftPos;
                    newLeftPos -= 150;
                    toolTips[i].style.left = newLeftPos.toString() + 'px';
                }
                else {
                    leftPos += ttleftOffset;
                    toolTips[i].style.left = leftPos.toString() + 'px';
                }
                var newTopPos = topPos;
                newTopPos += tttopOffset;
                toolTips[i].style.top = newTopPos.toString() + 'px';
            }
        }
    }));
    this.get_domEvents().attach('onmouseover', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var ttText = srcElement.getAttribute('toolTipText');
        if ((srcElement.className.indexOf('toolTip') >= 0) && (ttText !== '')) {
            var ttWidth = 150;
            var ttleftOffset = 10;
            var tttopOffset = 15;
            if (srcElement.getAttribute('toolTipWidth')) {
                ttWidth = srcElement.getAttribute('toolTipWidth');
                if (ttWidth > 500) {
                    ttWidth = 500;
                }
            }
            var leftPos = window.event.offsetX;
            var topPos = window.event.offsetY;
            var absoluteLeftPos = 0;
            var absoluteTopPos = 0;
            var offsetParent = srcElement;
            while (offsetParent) {
                absoluteLeftPos += offsetParent.offsetLeft;
                absoluteTopPos += offsetParent.offsetTop;
                offsetParent = offsetParent.offsetParent;
            }
            leftPos += absoluteLeftPos;
            topPos += absoluteTopPos;
            var screenWidth = window.document.body.offsetWidth;
            var screenHeight = window.document.body.offsetHeight;
            var toolTip = document.createElement('span');
            toolTip.className = 'tip-info';
            toolTip.innerHTML = ttText;
            if ((screenWidth - absoluteLeftPos) < (ttWidth + ttleftOffset)) {
                var newLeftPos = leftPos;
                newLeftPos -= ttWidth;
                toolTip.style.left = newLeftPos.toString() + 'px';
            }
            else {
                leftPos += ttleftOffset;
                toolTip.style.left = leftPos.toString() + 'px';
            }
            var newTopPos = topPos;
            newTopPos += tttopOffset;
            toolTip.style.top = newTopPos.toString() + 'px';
            srcElement.appendChild(toolTip);
        }
    }));
    this.get_domEvents().attach('onmouseout', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var toolTips = document.getElementsByTagName('span');
        for (var i = 0; i < toolTips.length; i++) {
            if (toolTips[i].className === 'tip-info') {
                srcElement.removeChild(toolTips[i]);
            }
        }
    }));
}


////////////////////////////////////////////////////////////////////////////////
// Framework.TransformAndUpdateTask

Framework.TransformAndUpdateTask = function Framework_TransformAndUpdateTask(domElementId, contentUrl, xsltUrl, xsltParameters, afterTransformAndUpdateCallback, domain, autoRefreshPeriod, environment, domElement, inMemoryProcessingCallback, contentXml, useSuppliedContentXml, contentUrlDelegate, useContentUrlDelegate) {
    this._domElementId = domElementId;
    this._contentUrl = contentUrl;
    this._xsltUrl = xsltUrl;
    this._xsltParameters = xsltParameters;
    this._afterTransformAndUpdateCallback = afterTransformAndUpdateCallback;
    this._domain = domain;
    this._environment = environment;
    this._autoRefreshPeriod = autoRefreshPeriod;
    this._domElement = domElement;
    this._inMemoryProcessingCallback = inMemoryProcessingCallback;
    this._useSuppliedContentXml = useSuppliedContentXml;
    if (this._useSuppliedContentXml) {
        this._contentXmlDocument = contentXml;
    }
    this._contentUrlDelegate = contentUrlDelegate;
    this._useContentUrlDelegate = useContentUrlDelegate;
    this._sdcToken = Framework.SDC.SDCManager.notLoggedInternalToken;
}
Framework.TransformAndUpdateTask._getStamp = function Framework_TransformAndUpdateTask$_getStamp(domElementId) {
    return Framework.TransformAndUpdateTask._domElementCounterMap[domElementId];
}
Framework.TransformAndUpdateTask._setStamp = function Framework_TransformAndUpdateTask$_setStamp(domElementId, value) {
    Framework.TransformAndUpdateTask._domElementCounterMap[domElementId] = value;
}
Framework.TransformAndUpdateTask.storeXsltDocument = function Framework_TransformAndUpdateTask$storeXsltDocument(url, document) {
    Framework.TransformAndUpdateTask._cachedXsltXmlDocument[url] = document;
}
Framework.TransformAndUpdateTask._onContentRequestsComplete = function Framework_TransformAndUpdateTask$_onContentRequestsComplete(contentUrl) {
    Framework.TransformAndUpdateTask._log.debug(String.format('OnContentRequestsComplete contentUrl=[{0}]', contentUrl));
    if (Object.keyExists(Framework.TransformAndUpdateTask._xmlCallBacks, contentUrl) && Object.getKeyCount((Framework.TransformAndUpdateTask._xmlCallBacks[contentUrl])) > 0) {
        var xmlCallBacksForUrl = Framework.TransformAndUpdateTask._xmlCallBacks[contentUrl];
        var $dict1 = xmlCallBacksForUrl;
        for (var $key2 in $dict1) {
            var callback = { key: $key2, value: $dict1[$key2] };
            Framework.TransformAndUpdateTask._log.debug(String.format('OnContentRequestsComplete callback key=[{0}] contentUrl=[{1}]', callback.key, contentUrl));
            (callback.value).invoke();
        }
    }
}
Framework.TransformAndUpdateTask.prototype = {
    _startingCounterValue: 0,
    _domElementId: null,
    _contentUrl: null,
    _contentUrlDelegate: null,
    _useContentUrlDelegate: false,
    _xsltUrl: null,
    _xsltParameters: null,
    _afterTransformAndUpdateCallback: null,
    _domain: null,
    
    get_domain: function Framework_TransformAndUpdateTask$get_domain() {
        return this._domain;
    },
    
    _autoRefreshPeriod: null,
    
    get_autoRefreshPeriod: function Framework_TransformAndUpdateTask$get_autoRefreshPeriod() {
        return this._autoRefreshPeriod;
    },
    
    _lastExecuted: null,
    
    get_lastExecuted: function Framework_TransformAndUpdateTask$get_lastExecuted() {
        return this._lastExecuted;
    },
    
    _contentRequest: null,
    _xsltRequest: null,
    _contentXmlDocument: null,
    _useSuppliedContentXml: false,
    _xsltXmlDocument: null,
    _environment: null,
    _inMemoryProcessingCallback: null,
    _domElement: null,
    _sdcToken: null,
    
    execute: function Framework_TransformAndUpdateTask$execute(appendTimestampToContentUrl) {
        this._lastExecuted = Date.get_now();
        this._startingCounterValue = Framework.TransformAndUpdateTask._requestCounter++;
        Framework.TransformAndUpdateTask._setStamp(this._domElementId, this._startingCounterValue);
        var newContentUrl = this._getContentUrl();
        if (this._contentUrl !== newContentUrl) {
            this._contentUrl = newContentUrl;
            this._contentXmlDocument = null;
        }
        if (!this._useSuppliedContentXml) {
            if (this._contentUrl) {
                var doCall = false;
                if (!Object.keyExists(Framework.TransformAndUpdateTask._xmlCallBacks, this._contentUrl) || !Object.getKeyCount((Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl]))) {
                    this._sdcToken = Framework.SDC.SDCManager.sdcManagerInstance().startRenderLog(this._domElementId);
                    doCall = true;
                    Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl] = {};
                }
                (Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl])[this._domElementId] = Delegate.create(this, this._onContentRequestComplete);
                if (doCall) {
                    this._contentXmlDocument = null;
                    this._contentRequest = new Framework.XMLHttpRequestDecorator();
                    this._contentRequest.onreadystatechange = Delegate.create(this, function() {
                        Framework.TransformAndUpdateTask._onContentRequestsComplete(this._contentUrl);
                    });
                    this._contentRequest.open('GET', this._contentUrl, true);
                    this._contentRequest.send(null);
                    Framework.TransformAndUpdateTask._contentRequests[this._contentUrl] = this._contentRequest;
                }
            }
            else {
                this._contentXmlDocument = Framework.XMLUtils.get_emptyContentDocument();
            }
        }
        if (!Object.keyExists(Framework.TransformAndUpdateTask._cachedXsltXmlDocument, this._xsltUrl)) {
            this._xsltRequest = new Framework.XMLHttpRequestDecorator();
            this._xsltRequest.onreadystatechange = Delegate.create(this, this._onXsltRequestComplete);
            this._xsltRequest.open('GET', this._xsltUrl, true);
            this._xsltRequest.send(null);
        }
        else {
            this._xsltXmlDocument = Framework.TransformAndUpdateTask._cachedXsltXmlDocument[this._xsltUrl];
        }
        this._tryTransform();
    },
    
    _tryTransform: function Framework_TransformAndUpdateTask$_tryTransform() {
        Framework.TransformAndUpdateTask._log.debug(String.format('TryTransform domElementId=[{0}] contentUrl=[{1}]', this._domElementId, this._contentUrl));
        if (this._contentXmlDocument && this._xsltXmlDocument && this._startingCounterValue === Framework.TransformAndUpdateTask._getStamp(this._domElementId)) {
            Framework.XMLUtils.transformAndUpdateWithXsltUrl(this._contentXmlDocument, this._xsltXmlDocument, this._xsltParameters, this._domElementId, this._domElement, this._getFullXsltUrl(this._xsltUrl), this._inMemoryProcessingCallback);
            if (this._afterTransformAndUpdateCallback) {
                window.setTimeout(this._afterTransformAndUpdateCallback, 0);
            }
            if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.mozilla) {
                var css = '#' + this._domElementId + ' .escapedHtml';
                var elements = Framework.DocumentFinder.getElementsBySelector(css);
                if (elements) {
                    for (var i = 0; i < elements.length; i++) {
                        elements[i].innerHTML = elements[i].innerText;
                    }
                }
            }
            Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.noException);
        }
    },
    
    _getFullXsltUrl: function Framework_TransformAndUpdateTask$_getFullXsltUrl(url) {
        return '/Areas/' + this._environment.getPageArea() + '/Template_' + this._environment.getRegion() + '_' + this._environment.getLanguage() + '/' + url;
    },
    
    _onContentRequestComplete: function Framework_TransformAndUpdateTask$_onContentRequestComplete() {
        if (!this._contentRequest) {
            this._contentRequest = Framework.TransformAndUpdateTask._contentRequests[this._contentUrl];
        }
        if (this._contentRequest) {
            if (this._contentRequest.readyState === 4) {
                if (this._contentRequest.status === 200 || this._contentRequest.status === 304) {
                    this._contentXmlDocument = this._contentRequest.responseXML;
                    this._tryTransform();
                }
                else {
                    Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.operationalException);
                    this._environment.updateDomElement(this._domElementId, '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
                }
                if (Object.keyExists(Framework.TransformAndUpdateTask._xmlCallBacks, this._contentUrl) && Object.getKeyCount((Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl])) > 0) {
                    var xmlCallBack = Framework.TransformAndUpdateTask._xmlCallBacks[this._contentUrl];
                    if (Object.keyExists(xmlCallBack, this._domElementId)) {
                        delete xmlCallBack[this._domElementId];
                    }
                    if (!Object.getKeyCount(xmlCallBack)) {
                        delete Framework.TransformAndUpdateTask._contentRequests[this._contentUrl];
                        this._contentRequest.onreadystatechange = null;
                    }
                }
            }
        }
    },
    
    _onXsltRequestComplete: function Framework_TransformAndUpdateTask$_onXsltRequestComplete() {
        if (this._xsltRequest.readyState === 4) {
            if (this._xsltRequest.status === 200 || this._xsltRequest.status === 304) {
                this._xsltXmlDocument = this._xsltRequest.responseXML;
                Framework.TransformAndUpdateTask._cachedXsltXmlDocument[this._xsltUrl] = this._xsltXmlDocument;
                this._tryTransform();
                if (this._xsltRequest) {
                    this._xsltRequest.onreadystatechange = null;
                }
            }
            else {
                Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.operationalException);
                this._environment.updateDomElement(this._domElementId, '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
            }
        }
    },
    
    _getContentUrl: function Framework_TransformAndUpdateTask$_getContentUrl() {
        if (this._useContentUrlDelegate) {
            return this._environment.createRealUrl(this._contentUrlDelegate.invoke());
        }
        else {
            return this._contentUrl;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.DOMParser

Framework.DOMParser = function Framework_DOMParser(parent) {
    this._index = {};
    this._parent = parent;
    this._createIndex(this._parent);
}
Framework.DOMParser.searchForElement = function Framework_DOMParser$searchForElement(domElement, ID) {
    if (!domElement) {
        return null;
    }
    if (domElement.id === ID) {
        return domElement;
    }
    for (var i = 0; i < domElement.childNodes.length; i++) {
        var el = Framework.DOMParser.searchForElement(domElement.childNodes[i], ID);
        if (el) {
            return el;
        }
    }
    return null;
}
Framework.DOMParser.prototype = {
    _parent: null,
    
    getElementByID: function Framework_DOMParser$getElementByID(id) {
        return this._index[id];
    },
    
    _createIndex: function Framework_DOMParser$_createIndex(domElement) {
        if (domElement.id !== '') {
            this._index[domElement.id] = domElement;
        }
        for (var i = 0; i < domElement.childNodes.length; i++) {
            this._createIndex(domElement.childNodes[i]);
        }
    },
    
    dispose: function Framework_DOMParser$dispose() {
        this._index = null;
    }
}


Type.createNamespace('Framework.Behavior.Binding');

////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.BehaviorBinder

Framework.Behavior.Binding.BehaviorBinder = function Framework_Behavior_Binding_BehaviorBinder() {
    this._tasks = {};
}
Framework.Behavior.Binding.BehaviorBinder.autoBind = function Framework_Behavior_Binding_BehaviorBinder$autoBind(domElement, component) {
    if (!component) {
        throw new Error('Component parameter can not be null');
    }
    if (!domElement) {
        throw new Error('DOMElement parameter can not be null');
    }
    Framework.Behavior.Binding.BehaviorBinder._searchAndBind(domElement, null, component);
}
Framework.Behavior.Binding.BehaviorBinder._searchAndBind = function Framework_Behavior_Binding_BehaviorBinder$_searchAndBind(startingPoint, tasks, component) {
    if (!isNullOrUndefined(startingPoint.attributes) && !isNullOrUndefined(startingPoint.getAttribute(Framework.Behavior.Binding.BehaviorBinder.behavioR_ID_ATTRIBUTE))) {
        var attValue = startingPoint.getAttributeNode(Framework.Behavior.Binding.BehaviorBinder.behavioR_ID_ATTRIBUTE).value;
        if (attValue.indexOf('|') === -1) {
            Framework.Behavior.Binding.BehaviorBinder._bindBehavior(startingPoint, attValue, tasks, component);
        }
        else {
            var behaviors = attValue.split('|');
            for (var i = 0; i < behaviors.length; i++) {
                Framework.Behavior.Binding.BehaviorBinder._bindBehavior(startingPoint, behaviors[i], tasks, component);
            }
        }
    }
    for (var i = 0; i < startingPoint.childNodes.length; i++) {
        if (startingPoint.childNodes[i].nodeType === 1) {
            Framework.Behavior.Binding.BehaviorBinder._searchAndBind(startingPoint.childNodes[i], tasks, component);
        }
    }
    startingPoint = null;
}
Framework.Behavior.Binding.BehaviorBinder._bindBehavior = function Framework_Behavior_Binding_BehaviorBinder$_bindBehavior(domElement, behaviorName, tasks, component) {
    if (tasks) {
        Framework.Behavior.Binding.BehaviorBinder._manualBehaviorBind(domElement, behaviorName, tasks);
    }
    else {
        Framework.Behavior.Binding.BehaviorBinder._autoBehaviorBind(domElement, behaviorName, component);
    }
}
Framework.Behavior.Binding.BehaviorBinder._manualBehaviorBind = function Framework_Behavior_Binding_BehaviorBinder$_manualBehaviorBind(domElement, behaviorName, tasks) {
    if (Object.keyExists(tasks, behaviorName)) {
        var binding = tasks[behaviorName];
        binding.bind(domElement);
    }
}
Framework.Behavior.Binding.BehaviorBinder._autoBehaviorBind = function Framework_Behavior_Binding_BehaviorBinder$_autoBehaviorBind(domElement, behaviorName, component) {
    var eventIDAttribute = domElement.getAttributeNode(Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_ID_ATTRIBUTE + '.' + behaviorName);
    if (!eventIDAttribute) {
        eventIDAttribute = domElement.getAttributeNode(Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_ID_ATTRIBUTE + '.' + behaviorName.toLowerCase());
        if (!eventIDAttribute) {
            return;
        }
    }
    var behaviorEvent = Framework.Behavior.ElementBehavior.stringToBehaviorEvent(eventIDAttribute.value);
    var handler = Framework.Behavior.Binding.BehaviorBinder._findEventHandler(component, behaviorName);
    if (!handler) {
        return;
    }
    switch (behaviorEvent) {
        case Framework.Behavior.BehaviorEvent.onclick:
            (new Framework.Behavior.Binding.OnClickBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onload:
            (new Framework.Behavior.Binding.OnLoadBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onchange:
            (new Framework.Behavior.Binding.OnChangeBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onkeyup:
            (new Framework.Behavior.Binding.OnKeyUpBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onmouseover:
            (new Framework.Behavior.Binding.OnMouseOverBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onmouseout:
            (new Framework.Behavior.Binding.OnMouseOutBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onfocus:
            (new Framework.Behavior.Binding.OnFocusBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onblur:
            (new Framework.Behavior.Binding.OnBlurBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onsubmit:
            (new Framework.Behavior.Binding.OnSubmitBinding(behaviorName, handler)).bind(domElement);
            break;
        case Framework.Behavior.BehaviorEvent.onkeydown:
            (new Framework.Behavior.Binding.OnKeyDownBinding(behaviorName, handler)).bind(domElement);
            break;
    }
}
Framework.Behavior.Binding.BehaviorBinder._findEventHandler = function Framework_Behavior_Binding_BehaviorBinder$_findEventHandler(component, behaviorName) {
    var handlerName = behaviorName + Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_HANDLER_SUFFIX;
    handlerName = handlerName.charAt(0).toString().toLowerCase() + handlerName.substr(1);
    var handler = component[handlerName];
    if (typeof(handler) !== 'function') {
        return null;
    }
    return Delegate.create(component, handler);
}
Framework.Behavior.Binding.BehaviorBinder.prototype = {
    
    addBinding: function Framework_Behavior_Binding_BehaviorBinder$addBinding(binding) {
        this._tasks[binding.get_behaviorID()] = binding;
    },
    
    bind: function Framework_Behavior_Binding_BehaviorBinder$bind(startingPoint) {
        if (isNullOrUndefined(this._tasks) || !Object.getKeyCount(this._tasks)) {
            return;
        }
        Framework.Behavior.Binding.BehaviorBinder._searchAndBind(startingPoint, this._tasks, null);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.AbstractBinding

Framework.Behavior.Binding.AbstractBinding = function Framework_Behavior_Binding_AbstractBinding(behaviorID, eventHandler) {
    this._behaviorID = behaviorID;
    this._eventHandler = eventHandler;
}
Framework.Behavior.Binding.AbstractBinding.prototype = {
    _behaviorID: null,
    
    get_behaviorID: function Framework_Behavior_Binding_AbstractBinding$get_behaviorID() {
        return this._behaviorID;
    },
    
    _eventHandler: null,
    
    get_eventHandler: function Framework_Behavior_Binding_AbstractBinding$get_eventHandler() {
        return this._eventHandler;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnKeyDownBinding

Framework.Behavior.Binding.OnKeyDownBinding = function Framework_Behavior_Binding_OnKeyDownBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnKeyDownBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnKeyDownBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnKeyDownBinding$bind(domElement) {
        new Framework.Behavior.OnKeyDownBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnSubmitBinding

Framework.Behavior.Binding.OnSubmitBinding = function Framework_Behavior_Binding_OnSubmitBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnSubmitBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnSubmitBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnSubmitBinding$bind(domElement) {
        new Framework.Behavior.OnSubmitBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnBlurBinding

Framework.Behavior.Binding.OnBlurBinding = function Framework_Behavior_Binding_OnBlurBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnBlurBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnBlurBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnBlurBinding$bind(domElement) {
        new Framework.Behavior.OnBlurBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnFocusBinding

Framework.Behavior.Binding.OnFocusBinding = function Framework_Behavior_Binding_OnFocusBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnFocusBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnFocusBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnFocusBinding$bind(domElement) {
        new Framework.Behavior.OnFocusBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnMouseOutBinding

Framework.Behavior.Binding.OnMouseOutBinding = function Framework_Behavior_Binding_OnMouseOutBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnMouseOutBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnMouseOutBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnMouseOutBinding$bind(domElement) {
        new Framework.Behavior.OnMouseOutBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnMouseOverBinding

Framework.Behavior.Binding.OnMouseOverBinding = function Framework_Behavior_Binding_OnMouseOverBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnMouseOverBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnMouseOverBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnMouseOverBinding$bind(domElement) {
        new Framework.Behavior.OnMouseOverBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnKeyUpBinding

Framework.Behavior.Binding.OnKeyUpBinding = function Framework_Behavior_Binding_OnKeyUpBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnKeyUpBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnKeyUpBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnKeyUpBinding$bind(domElement) {
        new Framework.Behavior.OnKeyUpBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnChangeBinding

Framework.Behavior.Binding.OnChangeBinding = function Framework_Behavior_Binding_OnChangeBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnChangeBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnChangeBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnChangeBinding$bind(domElement) {
        new Framework.Behavior.OnChangeBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnLoadBinding

Framework.Behavior.Binding.OnLoadBinding = function Framework_Behavior_Binding_OnLoadBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnLoadBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnLoadBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnLoadBinding$bind(domElement) {
        new Framework.Behavior.OnLoadBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.Binding.OnClickBinding

Framework.Behavior.Binding.OnClickBinding = function Framework_Behavior_Binding_OnClickBinding(behaviorID, eventHandler) {
    Framework.Behavior.Binding.OnClickBinding.constructBase(this, [ behaviorID, eventHandler ]);
}
Framework.Behavior.Binding.OnClickBinding.prototype = {
    
    bind: function Framework_Behavior_Binding_OnClickBinding$bind(domElement) {
        new Framework.Behavior.OnClickBehavior(domElement, this._behaviorID, this._eventHandler);
    }
}


Type.createNamespace('Framework.Behavior');

////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.BehaviorEvent

Framework.Behavior.BehaviorEvent = function() { };
Framework.Behavior.BehaviorEvent.prototype = {
    onclick: 0, 
    onload: 1, 
    onchange: 2, 
    onkeyup: 3, 
    onmouseover: 4, 
    onmouseout: 5, 
    onfocus: 6, 
    onblur: 7, 
    onsubmit: 8, 
    onkeydown: 9
}
Framework.Behavior.BehaviorEvent.createEnum('Framework.Behavior.BehaviorEvent', false);


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnKeyDownBehavior

Framework.Behavior.OnKeyDownBehavior = function Framework_Behavior_OnKeyDownBehavior(domElement, behaviorID, onKeyDownEventHandler) {
    Framework.Behavior.OnKeyDownBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onKeyDown(onKeyDownEventHandler);
}
Framework.Behavior.OnKeyDownBehavior.prototype = {
    _behaviorID$2: null,
    
    onKeyDownEventFired: function Framework_Behavior_OnKeyDownBehavior$onKeyDownEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnKeyDownEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onKeyDownEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnSubmitBehavior

Framework.Behavior.OnSubmitBehavior = function Framework_Behavior_OnSubmitBehavior(domElement, behaviorID, onSubmitEventHandler) {
    Framework.Behavior.OnSubmitBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onSubmit(onSubmitEventHandler);
}
Framework.Behavior.OnSubmitBehavior.prototype = {
    _behaviorID$2: null,
    
    onSubmitEventFired: function Framework_Behavior_OnSubmitBehavior$onSubmitEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnSubmitEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onSubmitEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnBlurBehavior

Framework.Behavior.OnBlurBehavior = function Framework_Behavior_OnBlurBehavior(domElement, behaviorID, onBlurEventHandler) {
    Framework.Behavior.OnBlurBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onBlur(onBlurEventHandler);
}
Framework.Behavior.OnBlurBehavior.prototype = {
    _behaviorID$2: null,
    
    onBlurEventFired: function Framework_Behavior_OnBlurBehavior$onBlurEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnBlurEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onBlurEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnFocusBehavior

Framework.Behavior.OnFocusBehavior = function Framework_Behavior_OnFocusBehavior(domElement, behaviorID, onFocusEventHandler) {
    Framework.Behavior.OnFocusBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onFocus(onFocusEventHandler);
}
Framework.Behavior.OnFocusBehavior.prototype = {
    _behaviorID$2: null,
    
    onFocusEventFired: function Framework_Behavior_OnFocusBehavior$onFocusEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnFocusEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onFocusEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnMouseOutBehavior

Framework.Behavior.OnMouseOutBehavior = function Framework_Behavior_OnMouseOutBehavior(domElement, behaviorID, onMouseOutEventHandler) {
    Framework.Behavior.OnMouseOutBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onMouseOut(onMouseOutEventHandler);
}
Framework.Behavior.OnMouseOutBehavior.prototype = {
    _behaviorID$2: null,
    
    onMouseOutEventFired: function Framework_Behavior_OnMouseOutBehavior$onMouseOutEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOutEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onMouseOutEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnMouseOverBehavior

Framework.Behavior.OnMouseOverBehavior = function Framework_Behavior_OnMouseOverBehavior(domElement, behaviorID, onMouseOverEventHandler) {
    Framework.Behavior.OnMouseOverBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onMouseOver(onMouseOverEventHandler);
}
Framework.Behavior.OnMouseOverBehavior.prototype = {
    _behaviorID$2: null,
    
    onMouseOverEventFired: function Framework_Behavior_OnMouseOverBehavior$onMouseOverEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOverEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onMouseOverEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnKeyUpBehavior

Framework.Behavior.OnKeyUpBehavior = function Framework_Behavior_OnKeyUpBehavior(domElement, behaviorID, onKeyUpEventHandler) {
    Framework.Behavior.OnKeyUpBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onKeyUp(onKeyUpEventHandler);
}
Framework.Behavior.OnKeyUpBehavior.prototype = {
    _behaviorID$2: null,
    
    onKeyUpEventFired: function Framework_Behavior_OnKeyUpBehavior$onKeyUpEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnKeyUpEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onKeyUpEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnChangeBehavior

Framework.Behavior.OnChangeBehavior = function Framework_Behavior_OnChangeBehavior(domElement, behaviorID, onChangeEventHandler) {
    Framework.Behavior.OnChangeBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onChange(onChangeEventHandler);
}
Framework.Behavior.OnChangeBehavior.prototype = {
    _behaviorID$2: null,
    
    onChangeEventFired: function Framework_Behavior_OnChangeBehavior$onChangeEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnChangeEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onChangeEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnLoadBehavior

Framework.Behavior.OnLoadBehavior = function Framework_Behavior_OnLoadBehavior(domElement, behaviorID, onLoadEventHandler) {
    var eventArgs = new Framework.Behavior.EventArgs.OnLoadEventArgs();
    eventArgs.domElement = domElement;
    eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(domElement, behaviorID));
    onLoadEventHandler.invoke(this, eventArgs);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.OnClickBehavior

Framework.Behavior.OnClickBehavior = function Framework_Behavior_OnClickBehavior(domElement, behaviorID, onClickEventHandler) {
    Framework.Behavior.OnClickBehavior.constructBase(this, [ domElement ]);
    this._behaviorID$2 = behaviorID;
    this.add_onClick(onClickEventHandler);
}
Framework.Behavior.OnClickBehavior.prototype = {
    _behaviorID$2: null,
    
    onClickEventFired: function Framework_Behavior_OnClickBehavior$onClickEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnClickEventArgs();
        eventArgs.domElement = this.get_domElement();
        eventArgs.parameters = new Framework.Behavior.EventArgs.Parameters(Framework.Behavior.ParametersObjectBuilder.build(this.get_domElement(), this._behaviorID$2));
        this._onClickEventHandler.invoke(this, eventArgs);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.ElementBehavior

Framework.Behavior.ElementBehavior = function Framework_Behavior_ElementBehavior(domElement) {
    Framework.Behavior.ElementBehavior.constructBase(this, [ domElement, null ]);
}
Framework.Behavior.ElementBehavior.detachEvent = function Framework_Behavior_ElementBehavior$detachEvent(domElement, eventName) {
    var behaviors = 'ScriptFX.UI.Behavior'.getBehaviors(domElement, null);
    if (!behaviors) {
        return;
    }
    var $enum1 = behaviors.getEnumerator();
    while ($enum1.moveNext()) {
        var behavior = $enum1.get_current();
        switch (eventName) {
            case Framework.Behavior.BehaviorEvent.onclick:
                if (behavior.detachAllOnClick) {
                    (behavior).detachAllOnClick();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onchange:
                if (behavior.detachAllOnChange) {
                    (behavior).detachAllOnChange();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onkeyup:
                if (behavior.detachAllOnKeyUp) {
                    (behavior).detachAllOnKeyUp();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onmouseover:
                if (behavior.detachAllOnMouseOver) {
                    (behavior).detachAllOnMouseOver();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onmouseout:
                if (behavior.detachAllOnMouseOut) {
                    (behavior).detachAllOnMouseOut();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onfocus:
                if (behavior.detachAllOnFocus) {
                    (behavior).detachAllOnFocus();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onblur:
                if (behavior.detachAllOnBlur) {
                    (behavior).detachAllOnBlur();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onsubmit:
                if (behavior.detachAllOnSubmit) {
                    (behavior).detachAllOnSubmit();
                }
                break;
            case Framework.Behavior.BehaviorEvent.onkeydown:
                if (behavior.detachAllOnKeyDown) {
                    (behavior).detachAllOnKeyDown();
                }
                break;
        }
    }
}
Framework.Behavior.ElementBehavior.behaviorEventToString = function Framework_Behavior_ElementBehavior$behaviorEventToString(eventName) {
    switch (eventName) {
        case Framework.Behavior.BehaviorEvent.onclick:
            return 'onclick';
        case Framework.Behavior.BehaviorEvent.onload:
            return 'onload';
        case Framework.Behavior.BehaviorEvent.onchange:
            return 'onchange';
        case Framework.Behavior.BehaviorEvent.onkeyup:
            return 'onkeyup';
        case Framework.Behavior.BehaviorEvent.onmouseover:
            return 'onmouseover';
        case Framework.Behavior.BehaviorEvent.onmouseout:
            return 'onmouseout';
        case Framework.Behavior.BehaviorEvent.onfocus:
            return 'onfocus';
        case Framework.Behavior.BehaviorEvent.onblur:
            return 'onblur';
        case Framework.Behavior.BehaviorEvent.onsubmit:
            return 'onsubmit';
        case Framework.Behavior.BehaviorEvent.onkeydown:
            return 'onkeydown';
        default:
            throw new Error('Behavior event name not recognized');
    }
}
Framework.Behavior.ElementBehavior.stringToBehaviorEvent = function Framework_Behavior_ElementBehavior$stringToBehaviorEvent(eventName) {
    switch (eventName) {
        case 'onclick':
            return Framework.Behavior.BehaviorEvent.onclick;
        case 'onload':
            return Framework.Behavior.BehaviorEvent.onload;
        case 'onchange':
            return Framework.Behavior.BehaviorEvent.onchange;
        case 'onkeyup':
            return Framework.Behavior.BehaviorEvent.onkeyup;
        case 'onmouseover':
            return Framework.Behavior.BehaviorEvent.onmouseover;
        case 'onmouseout':
            return Framework.Behavior.BehaviorEvent.onmouseout;
        case 'onfocus':
            return Framework.Behavior.BehaviorEvent.onfocus;
        case 'onblur':
            return Framework.Behavior.BehaviorEvent.onblur;
        case 'onsubmit':
            return Framework.Behavior.BehaviorEvent.onsubmit;
        case 'onkeydown':
            return Framework.Behavior.BehaviorEvent.onkeydown;
        default:
            throw new Error('Behavior event name not recognized');
    }
}
Framework.Behavior.ElementBehavior.prototype = {
    isBehaviorDisposed: false,
    _onClickEventHandler: null,
    
    add_onClick: function Framework_Behavior_ElementBehavior$add_onClick(value) {
        this._onClickEventHandler = Delegate.combine(this._onClickEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick), Delegate.create(this, this.onClickEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onclick, value);
        }
    },
    remove_onClick: function Framework_Behavior_ElementBehavior$remove_onClick(value) {
        this._onClickEventHandler = Delegate.remove(this._onClickEventHandler, value);
        if (!this._onClickEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onclick);
        }
    },
    
    detachAllOnClick: function Framework_Behavior_ElementBehavior$detachAllOnClick() {
        this._onClickEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onclick));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onclick);
    },
    
    onClickEventFired: function Framework_Behavior_ElementBehavior$onClickEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnClickEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onClickEventHandler.invoke(this, eventArgs);
    },
    
    _onChangeEventHandler: null,
    
    add_onChange: function Framework_Behavior_ElementBehavior$add_onChange(value) {
        this._onChangeEventHandler = Delegate.combine(this._onChangeEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange), Delegate.create(this, this.onChangeEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onchange, value);
        }
    },
    remove_onChange: function Framework_Behavior_ElementBehavior$remove_onChange(value) {
        this._onChangeEventHandler = Delegate.remove(this._onChangeEventHandler, value);
        if (!this._onChangeEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onchange);
        }
    },
    
    detachAllOnChange: function Framework_Behavior_ElementBehavior$detachAllOnChange() {
        this._onChangeEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onchange));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onchange);
    },
    
    onChangeEventFired: function Framework_Behavior_ElementBehavior$onChangeEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnChangeEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onChangeEventHandler.invoke(this, eventArgs);
    },
    
    _onKeyUpEventHandler: null,
    
    add_onKeyUp: function Framework_Behavior_ElementBehavior$add_onKeyUp(value) {
        this._onKeyUpEventHandler = Delegate.combine(this._onKeyUpEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup), Delegate.create(this, this.onKeyUpEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeyup, value);
        }
    },
    remove_onKeyUp: function Framework_Behavior_ElementBehavior$remove_onKeyUp(value) {
        this._onKeyUpEventHandler = Delegate.remove(this._onKeyUpEventHandler, value);
        if (!this._onKeyUpEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeyup);
        }
    },
    
    detachAllOnKeyUp: function Framework_Behavior_ElementBehavior$detachAllOnKeyUp() {
        this._onKeyUpEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeyup);
    },
    
    onKeyUpEventFired: function Framework_Behavior_ElementBehavior$onKeyUpEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnKeyUpEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onKeyUpEventHandler.invoke(this, eventArgs);
    },
    
    _onMouseOverEventHandler: null,
    
    add_onMouseOver: function Framework_Behavior_ElementBehavior$add_onMouseOver(value) {
        this._onMouseOverEventHandler = Delegate.combine(this._onMouseOverEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover), Delegate.create(this, this.onMouseOverEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseover, value);
        }
    },
    remove_onMouseOver: function Framework_Behavior_ElementBehavior$remove_onMouseOver(value) {
        this._onMouseOverEventHandler = Delegate.remove(this._onMouseOverEventHandler, value);
        if (!this._onMouseOverEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseover);
        }
    },
    
    detachAllOnMouseOver: function Framework_Behavior_ElementBehavior$detachAllOnMouseOver() {
        this._onMouseOverEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseover));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseover);
    },
    
    onMouseOverEventFired: function Framework_Behavior_ElementBehavior$onMouseOverEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOverEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onMouseOverEventHandler.invoke(this, eventArgs);
    },
    
    _onMouseOutEventHandler: null,
    
    add_onMouseOut: function Framework_Behavior_ElementBehavior$add_onMouseOut(value) {
        this._onMouseOutEventHandler = Delegate.combine(this._onMouseOutEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout), Delegate.create(this, this.onMouseOutEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseout, value);
        }
    },
    remove_onMouseOut: function Framework_Behavior_ElementBehavior$remove_onMouseOut(value) {
        this._onMouseOutEventHandler = Delegate.remove(this._onMouseOutEventHandler, value);
        if (!this._onMouseOutEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseout);
        }
    },
    
    detachAllOnMouseOut: function Framework_Behavior_ElementBehavior$detachAllOnMouseOut() {
        this._onMouseOutEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onmouseout));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onmouseout);
    },
    
    onMouseOutEventFired: function Framework_Behavior_ElementBehavior$onMouseOutEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnMouseOutEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onMouseOutEventHandler.invoke(this, eventArgs);
    },
    
    _onFocusEventHandler: null,
    
    add_onFocus: function Framework_Behavior_ElementBehavior$add_onFocus(value) {
        this._onFocusEventHandler = Delegate.combine(this._onFocusEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus), Delegate.create(this, this.onFocusEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onfocus, value);
        }
    },
    remove_onFocus: function Framework_Behavior_ElementBehavior$remove_onFocus(value) {
        this._onFocusEventHandler = Delegate.remove(this._onFocusEventHandler, value);
        if (!this._onFocusEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onfocus);
        }
    },
    
    detachAllOnFocus: function Framework_Behavior_ElementBehavior$detachAllOnFocus() {
        this._onFocusEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onfocus));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onfocus);
    },
    
    onFocusEventFired: function Framework_Behavior_ElementBehavior$onFocusEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnFocusEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onFocusEventHandler.invoke(this, eventArgs);
    },
    
    _onBlurEventHandler: null,
    
    add_onBlur: function Framework_Behavior_ElementBehavior$add_onBlur(value) {
        this._onBlurEventHandler = Delegate.combine(this._onBlurEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur), Delegate.create(this, this.onBlurEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onblur, value);
        }
    },
    remove_onBlur: function Framework_Behavior_ElementBehavior$remove_onBlur(value) {
        this._onBlurEventHandler = Delegate.remove(this._onBlurEventHandler, value);
        if (!this._onBlurEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onblur);
        }
    },
    
    detachAllOnBlur: function Framework_Behavior_ElementBehavior$detachAllOnBlur() {
        this._onBlurEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onblur));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onblur);
    },
    
    onBlurEventFired: function Framework_Behavior_ElementBehavior$onBlurEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnBlurEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onBlurEventHandler.invoke(this, eventArgs);
    },
    
    _onSubmitEventHandler: null,
    
    add_onSubmit: function Framework_Behavior_ElementBehavior$add_onSubmit(value) {
        this._onSubmitEventHandler = Delegate.combine(this._onSubmitEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit), Delegate.create(this, this.onSubmitEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onsubmit, value);
        }
    },
    remove_onSubmit: function Framework_Behavior_ElementBehavior$remove_onSubmit(value) {
        this._onSubmitEventHandler = Delegate.remove(this._onSubmitEventHandler, value);
        if (!this._onBlurEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onsubmit);
        }
    },
    
    detachAllOnSubmit: function Framework_Behavior_ElementBehavior$detachAllOnSubmit() {
        this._onSubmitEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onsubmit));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onsubmit);
    },
    
    onSubmitEventFired: function Framework_Behavior_ElementBehavior$onSubmitEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnSubmitEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onSubmitEventHandler.invoke(this, eventArgs);
    },
    
    _onKeyDownEventHandler: null,
    
    add_onKeyDown: function Framework_Behavior_ElementBehavior$add_onKeyDown(value) {
        this._onKeyDownEventHandler = Delegate.combine(this._onKeyDownEventHandler, value);
        if (!this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeydown))) {
            this.get_domEvents().attach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeydown), Delegate.create(this, this.onKeyDownEventFired));
            this._addDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeydown, value);
        }
    },
    remove_onKeyDown: function Framework_Behavior_ElementBehavior$remove_onKeyDown(value) {
        this._onKeyDownEventHandler = Delegate.remove(this._onKeyDownEventHandler, value);
        if (!this._onKeyDownEventHandler) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeydown));
            this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeydown);
        }
    },
    
    detachAllOnKeyDown: function Framework_Behavior_ElementBehavior$detachAllOnKeyDown() {
        this._onKeyDownEventHandler = null;
        if (this.get_domEvents().isAttached(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup))) {
            this.get_domEvents().detach(Framework.Behavior.ElementBehavior.behaviorEventToString(Framework.Behavior.BehaviorEvent.onkeyup));
        }
        this._removeDebugAttribute$1(Framework.Behavior.BehaviorEvent.onkeydown);
    },
    
    onKeyDownEventFired: function Framework_Behavior_ElementBehavior$onKeyDownEventFired() {
        var eventArgs = new Framework.Behavior.EventArgs.OnKeyDownEventArgs();
        eventArgs.domElement = this.get_domElement();
        this._onKeyDownEventHandler.invoke(this, eventArgs);
    },
    
    dispose: function Framework_Behavior_ElementBehavior$dispose() {
        if (this.isBehaviorDisposed) {
            return;
        }
        if (!this.get_isDisposed()) {
            this.get_domEvents().dispose();
            Framework.Behavior.ElementBehavior.callBase(this, 'dispose');
        }
        this._onClickEventHandler = null;
        this._onChangeEventHandler = null;
        this._onKeyUpEventHandler = null;
        this._onMouseOverEventHandler = null;
        this._onMouseOutEventHandler = null;
        this._onFocusEventHandler = null;
        this._onBlurEventHandler = null;
        this._onSubmitEventHandler = null;
        this._onKeyDownEventHandler = null;
        this.isBehaviorDisposed = true;
    },
    
    _addDebugAttribute$1: function Framework_Behavior_ElementBehavior$_addDebugAttribute$1(eventName, value) {
        if (this.get__isDevelopmentModeTurnedOn$1()) {
            this.get_domElement().setAttribute(this._getDebugAttributeName$1(eventName), this._getDelegateDebugInfo$1(value));
        }
    },
    
    _removeDebugAttribute$1: function Framework_Behavior_ElementBehavior$_removeDebugAttribute$1(eventName) {
        if (this.get__isDevelopmentModeTurnedOn$1()) {
            this.get_domElement().removeAttribute(this._getDebugAttributeName$1(eventName));
        }
    },
    
    _getDebugAttributeName$1: function Framework_Behavior_ElementBehavior$_getDebugAttributeName$1(eventName) {
        return 'debug.behavior.' + Framework.Behavior.ElementBehavior.behaviorEventToString(eventName) + '_boundto';
    },
    
    get__isDevelopmentModeTurnedOn$1: function Framework_Behavior_ElementBehavior$get__isDevelopmentModeTurnedOn$1() {
        return Framework.AbstractEnvironment._debugMode;
    },
    
    _getDelegateDebugInfo$1: function Framework_Behavior_ElementBehavior$_getDelegateDebugInfo$1(value) {
        return Framework.Util.DebugInfoProvider.delegateDebugInfo(value);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.UrlRewrittingInfoObject

Framework.Behavior.UrlRewrittingInfoObject = function Framework_Behavior_UrlRewrittingInfoObject() {
    this.urlItems = {};
    this.descriptiveItems = [];
}
Framework.Behavior.UrlRewrittingInfoObject.prototype = {
    pageArea: null,
    region: null,
    
    addUrlItem: function Framework_Behavior_UrlRewrittingInfoObject$addUrlItem(key, value) {
    }
}


Type.createNamespace('Framework.Behavior.EventArgs');

////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnKeyDownEventArgs

Framework.Behavior.EventArgs.OnKeyDownEventArgs = function Framework_Behavior_EventArgs_OnKeyDownEventArgs() {
    Framework.Behavior.EventArgs.OnKeyDownEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnSubmitEventArgs

Framework.Behavior.EventArgs.OnSubmitEventArgs = function Framework_Behavior_EventArgs_OnSubmitEventArgs() {
    Framework.Behavior.EventArgs.OnSubmitEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnBlurEventArgs

Framework.Behavior.EventArgs.OnBlurEventArgs = function Framework_Behavior_EventArgs_OnBlurEventArgs() {
    Framework.Behavior.EventArgs.OnBlurEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnFocusEventArgs

Framework.Behavior.EventArgs.OnFocusEventArgs = function Framework_Behavior_EventArgs_OnFocusEventArgs() {
    Framework.Behavior.EventArgs.OnFocusEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnMouseOutEventArgs

Framework.Behavior.EventArgs.OnMouseOutEventArgs = function Framework_Behavior_EventArgs_OnMouseOutEventArgs() {
    Framework.Behavior.EventArgs.OnMouseOutEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnMouseOverEventArgs

Framework.Behavior.EventArgs.OnMouseOverEventArgs = function Framework_Behavior_EventArgs_OnMouseOverEventArgs() {
    Framework.Behavior.EventArgs.OnMouseOverEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnKeyUpEventArgs

Framework.Behavior.EventArgs.OnKeyUpEventArgs = function Framework_Behavior_EventArgs_OnKeyUpEventArgs() {
    Framework.Behavior.EventArgs.OnKeyUpEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.Parameters

Framework.Behavior.EventArgs.Parameters = function Framework_Behavior_EventArgs_Parameters(parameters) {
    this._parameters = parameters;
}
Framework.Behavior.EventArgs.Parameters.prototype = {
    _parameters: null,
    
    getAsInt32: function Framework_Behavior_EventArgs_Parameters$getAsInt32(parametername) {
        return Framework.Util.StringConverter.getAsInt32(this._parameters[parametername]);
    },
    
    getAsNumber: function Framework_Behavior_EventArgs_Parameters$getAsNumber(parametername) {
        return Framework.Util.StringConverter.getAsNumber(this._parameters[parametername]);
    },
    
    getAsString: function Framework_Behavior_EventArgs_Parameters$getAsString(parametername) {
        return Framework.Util.StringConverter.getAsString(this._parameters[parametername]);
    },
    
    getAsStringArray: function Framework_Behavior_EventArgs_Parameters$getAsStringArray(parametername) {
        return Framework.Util.StringConverter.getAsStringArray(this._parameters[parametername]);
    },
    
    getAsNumberArray: function Framework_Behavior_EventArgs_Parameters$getAsNumberArray(parametername) {
        return Framework.Util.StringConverter.getAsNumberArray(this._parameters[parametername]);
    },
    
    getAsBoolean: function Framework_Behavior_EventArgs_Parameters$getAsBoolean(parametername) {
        return Framework.Util.StringConverter.getAsBoolean(this._parameters[parametername]);
    },
    
    getAsEscapedString: function Framework_Behavior_EventArgs_Parameters$getAsEscapedString(parametername) {
        return Framework.Util.StringConverter.getAsEscapedString(this._parameters[parametername]);
    },
    
    getAsDictionary: function Framework_Behavior_EventArgs_Parameters$getAsDictionary(parametername) {
        return Framework.Util.StringConverter.getAsDictionary(this._parameters[parametername]);
    },
    
    containsKey: function Framework_Behavior_EventArgs_Parameters$containsKey(parametername) {
        return Object.keyExists(this._parameters, parametername);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnLoadEventArgs

Framework.Behavior.EventArgs.OnLoadEventArgs = function Framework_Behavior_EventArgs_OnLoadEventArgs() {
    Framework.Behavior.EventArgs.OnLoadEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.BehaviorEventArgs

Framework.Behavior.EventArgs.BehaviorEventArgs = function Framework_Behavior_EventArgs_BehaviorEventArgs() {
}
Framework.Behavior.EventArgs.BehaviorEventArgs.prototype = {
    domElement: null,
    parameters: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnChangeEventArgs

Framework.Behavior.EventArgs.OnChangeEventArgs = function Framework_Behavior_EventArgs_OnChangeEventArgs() {
    Framework.Behavior.EventArgs.OnChangeEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Behavior.EventArgs.OnClickEventArgs

Framework.Behavior.EventArgs.OnClickEventArgs = function Framework_Behavior_EventArgs_OnClickEventArgs() {
    Framework.Behavior.EventArgs.OnClickEventArgs.constructBase(this);
}


Type.createNamespace('Framework.Component');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.IDynamicComponent

Framework.Component.IDynamicComponent = function() { };
Framework.Component.IDynamicComponent.prototype = {
    get_componentLifeCycleManager : null,
    get_componentInstanceName : null,
    get_domElementId : null,
    createDynamicComponent : null,
    killAllDynamicChildComponents : null,
    dispose : null
}
Framework.Component.IDynamicComponent.createInterface('Framework.Component.IDynamicComponent');


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.AbstractComponent

Framework.Component.AbstractComponent = function Framework_Component_AbstractComponent() {
    this._log = Framework.Logger.getLog('AbstractComponent');
    this._children = new Array(0);
    this._dynamicChildren = new Array(0);
    this._dynamicChildrenHashTable = {};
    this._componentLifeCycleManager = this.createComponentLifeCycleManager();
}
Framework.Component.AbstractComponent.setFormEnabled = function Framework_Component_AbstractComponent$setFormEnabled(domElementId, enabled) {
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('select'), enabled);
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('input'), enabled);
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('button'), enabled);
    Framework.Component.AbstractComponent._setCollectionEnabled(document.getElementById(domElementId).getElementsByTagName('textarea'), enabled);
}
Framework.Component.AbstractComponent._setCollectionEnabled = function Framework_Component_AbstractComponent$_setCollectionEnabled(domElementCollection, enabled) {
    for (var i = 0; i < domElementCollection.length; i++) {
        domElementCollection[i].disabled = !enabled;
    }
}
Framework.Component.AbstractComponent.prototype = {
    _environment: null,
    _componentInstanceName: null,
    _domElementId: null,
    _currentArea: 0,
    _area: null,
    _adminHtmlUrl: null,
    _childID: null,
    _cssClass: null,
    _visibleNavigationTypes: null,
    
    get_visibleNavigationTypes: function Framework_Component_AbstractComponent$get_visibleNavigationTypes() {
        return this._visibleNavigationTypes;
    },
    
    get_cssClass: function Framework_Component_AbstractComponent$get_cssClass() {
        return this._cssClass;
    },
    
    _parent: null,
    _siblingIndex: 0,
    _componentLifeCycleManager: null,
    
    get_componentLifeCycleManager: function Framework_Component_AbstractComponent$get_componentLifeCycleManager() {
        return this._componentLifeCycleManager;
    },
    
    childrenUpdateComplete: function Framework_Component_AbstractComponent$childrenUpdateComplete(eventArgs) {
    },
    
    childComponentUpdateComplete: function Framework_Component_AbstractComponent$childComponentUpdateComplete(eventArgs) {
    },
    
    createDynamicComponent: function Framework_Component_AbstractComponent$createDynamicComponent(componentType, placeholder, startComponent, customComponentParameters) {
        var component = Framework.Component.ComponentFactory.createDynamicComponent(componentType, this, placeholder, customComponentParameters, startComponent);
        this._dynamicChildren[this._dynamicChildren.length] = component;
        this._dynamicChildrenHashTable[component.get_componentInstanceName()] = component;
        return component.get_componentInstanceName();
    },
    
    killDynamicChildComponent: function Framework_Component_AbstractComponent$killDynamicChildComponent(component) {
        if (!this._dynamicChildren.contains(component)) {
            throw new Error(String.format('Error: AbstractComponent, RemoveDynamicComponent => Component \'{0}\' is not child component of the component \'{1}\'', component.get_componentInstanceName(), this.get_componentInstanceName()));
        }
        Framework.Component.ComponentFactory.deleteComponent(component);
        var newArray = new Array(0);
        var $enum1 = this._dynamicChildren.getEnumerator();
        while ($enum1.moveNext()) {
            var com = $enum1.get_current();
            if (com !== component) {
                newArray[newArray.length] = com;
            }
        }
        this._dynamicChildren = newArray;
        this._dynamicChildrenHashTable[component.get_componentInstanceName()] = null;
    },
    
    killAllDynamicChildComponents: function Framework_Component_AbstractComponent$killAllDynamicChildComponents() {
        var $enum1 = this._dynamicChildren.getEnumerator();
        while ($enum1.moveNext()) {
            var component = $enum1.get_current();
            Framework.Component.ComponentFactory.deleteComponent(component);
        }
        this._dynamicChildren = new Array(0);
        this._dynamicChildrenHashTable = {};
    },
    
    get_hasDynamicChildren: function Framework_Component_AbstractComponent$get_hasDynamicChildren() {
        return ((this._dynamicChildren) && (this._dynamicChildren.length > 0));
    },
    
    get_dynamicChildren: function Framework_Component_AbstractComponent$get_dynamicChildren() {
        return this._dynamicChildren;
    },
    
    getDynamicChildByInstanceName: function Framework_Component_AbstractComponent$getDynamicChildByInstanceName(instanceName) {
        return this._dynamicChildrenHashTable[instanceName];
    },
    
    dispose: function Framework_Component_AbstractComponent$dispose() {
    },
    
    get_componentInstanceName: function Framework_Component_AbstractComponent$get_componentInstanceName() {
        return this._componentInstanceName;
    },
    
    get_domElementId: function Framework_Component_AbstractComponent$get_domElementId() {
        return this._domElementId;
    },
    set_domElementId: function Framework_Component_AbstractComponent$set_domElementId(value) {
        this._domElementId = value;
        return value;
    },
    
    init: function Framework_Component_AbstractComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._log = Framework.Logger.getLog(domElementId);
        this._log.debug('Init');
        this._environment = environment;
        this._componentInstanceName = componentInstanceName;
        this._domElementId = domElementId;
        this._adminHtmlUrl = parameters['admin-html-url'];
        this._cssClass = parameters['css-class'];
        if (!String.isNullOrEmpty(parameters['visible-navigation-types'])) {
            this._visibleNavigationTypes = ScriptFX.JSON.deserialize((parameters['visible-navigation-types']));
        }
    },
    
    start: function Framework_Component_AbstractComponent$start() {
        this._log.debug('Start');
    },
    
    repaintForAdmin: function Framework_Component_AbstractComponent$repaintForAdmin() {
        var ajaxUpdater = new Framework.AjaxUpdater(this._domElementId, this._adminHtmlUrl, null, Delegate.create(this, function() {
            this._environment.updateDomElement(this._domElementId, this._domElementId);
        }));
        ajaxUpdater.update();
    },
    
    createComponentLifeCycleManager: function Framework_Component_AbstractComponent$createComponentLifeCycleManager() {
        return new Framework.Component.LifeCycleManagement.ComponentLifeCycleManager(this);
    },
    
    disableForAdmin: function Framework_Component_AbstractComponent$disableForAdmin() {
        var anchors = this._environment.getDomElement(this._domElementId).getElementsByTagName('A');
        for (var i = 0; i < anchors.length; i++) {
            var anchor = anchors[i];
            anchor.setAttribute('href', '#');
            anchor.setAttribute('onclick', 'return false;');
        }
    },
    
    isVisible: function Framework_Component_AbstractComponent$isVisible(visibleOn, notVisibleOn, action) {
        if (!visibleOn.length && !notVisibleOn.length) {
            return true;
        }
        if (visibleOn.length > 0) {
            return visibleOn.contains(action);
        }
        if (notVisibleOn.length > 0) {
            return !notVisibleOn.contains(action);
        }
        throw new Error('Parameters were not specified correctly.');
    },
    
    isNavigationTypesInAValidCombination: function Framework_Component_AbstractComponent$isNavigationTypesInAValidCombination(currentNavTypes) {
        var navtypesToCheck = this.get_visibleNavigationTypes();
        if (!currentNavTypes) {
            return true;
        }
        if (!navtypesToCheck) {
            return true;
        }
        for (var count = 0; count < navtypesToCheck.length; count++) {
            if (navtypesToCheck[count].isMatch(currentNavTypes)) {
                return true;
            }
        }
        return false;
    },
    
    show: function Framework_Component_AbstractComponent$show() {
        if (!this.get_domElementId()) {
            return;
        }
        if (!this._environment.getDomElement(this.get_domElementId())) {
            return;
        }
        this._environment.getDomElement(this.get_domElementId()).style.display = 'block';
    },
    
    hide: function Framework_Component_AbstractComponent$hide() {
        if (!this.get_domElementId()) {
            return;
        }
        if (!this._environment.getDomElement(this.get_domElementId())) {
            return;
        }
        this._environment.getDomElement(this.get_domElementId()).style.display = 'none';
    },
    
    disable: function Framework_Component_AbstractComponent$disable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'wait';
        Framework.Component.AbstractComponent.setFormEnabled(this._domElementId, false);
    },
    
    enable: function Framework_Component_AbstractComponent$enable() {
        this._environment.getDomElement(this._domElementId).style.cursor = 'default';
        Framework.Component.AbstractComponent.setFormEnabled(this._domElementId, true);
    },
    
    getPrivateDomElement: function Framework_Component_AbstractComponent$getPrivateDomElement(domElementNameSuffix) {
        return document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
    },
    
    updatePrivateDomElement: function Framework_Component_AbstractComponent$updatePrivateDomElement(domElementNameSuffix, htmlContent) {
        this.updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, null, null);
    },
    
    updatePrivateDomElementWithCallback: function Framework_Component_AbstractComponent$updatePrivateDomElementWithCallback(domElementNameSuffix, htmlContent, successCallback, failureCallback) {
        try {
            var element = document.getElementById(String.format('{0}-{1}', this._domElementId, domElementNameSuffix));
            if (element) {
                this._environment.updateDomElementDirect(element, htmlContent);
                if (successCallback) {
                    successCallback.invoke();
                }
            }
            else {
                throw new Error(String.format('domElementNameSuffix [{0}] cannot be found!', domElementNameSuffix));
            }
        }
        catch (ex) {
            this._log.error('UpdatePrivateDomElement', ex);
            if (failureCallback) {
                failureCallback.invoke(ex);
            }
        }
    },
    
    activateArea: function Framework_Component_AbstractComponent$activateArea(area, messages) {
        this._log.debug(String.format('ActivateArea area=[{0}] messages=[{1}]', area, messages));
        var areaElement = this.getPrivateDomElement(this._area[this._currentArea]);
        if (areaElement) {
            areaElement.style.display = 'none';
        }
        this._currentArea = area;
        areaElement = this.getPrivateDomElement(this._area[this._currentArea]);
        if (areaElement) {
            areaElement.style.display = 'block';
        }
        if (messages) {
            for (var i = 0; i < messages.length; i++) {
                if (!String.isNullOrEmpty(messages[i])) {
                    this.getPrivateDomElement(this._area[this._currentArea] + '-' + i).innerText = messages[i];
                }
            }
        }
    },
    
    getTranslation: function Framework_Component_AbstractComponent$getTranslation(phrase) {
        return this.getPrivateDomElement(phrase).innerHTML;
    },
    
    get_parent: function Framework_Component_AbstractComponent$get_parent() {
        return this._parent;
    },
    
    get_childID: function Framework_Component_AbstractComponent$get_childID() {
        return this._childID;
    },
    set_childID: function Framework_Component_AbstractComponent$set_childID(value) {
        this._childID = value;
        return value;
    },
    
    startChildren: function Framework_Component_AbstractComponent$startChildren() {
        for (var index = 0; index < this._children.length; index++) {
            var newComponent = (this._children[index]);
            if (!isNullOrUndefined(newComponent.get_componentLifeCycleManager())) {
                newComponent.get_componentLifeCycleManager().start();
            }
            else {
                this._children[index].start();
            }
        }
    },
    
    addChild: function Framework_Component_AbstractComponent$addChild(child) {
        var index = this._children.length;
        this._children[index] = child;
        child._parent = this;
        child._siblingIndex = index;
    },
    
    get_hasChildren: function Framework_Component_AbstractComponent$get_hasChildren() {
        if (!this._children) {
            return false;
        }
        return this._children.length > 0;
    },
    
    get_children: function Framework_Component_AbstractComponent$get_children() {
        return this._children;
    },
    
    getChildByID: function Framework_Component_AbstractComponent$getChildByID(childID) {
        for (var count = 0; count < this._children.length; count++) {
            if (this._children[count].get_childID() === childID) {
                return this._children[count];
            }
        }
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.ComponentFactory

Framework.Component.ComponentFactory = function Framework_Component_ComponentFactory() {
}
Framework.Component.ComponentFactory.create = function Framework_Component_ComponentFactory$create(componentName, componentConfigurationItem, placeholderId, environment) {
    Framework.Component.ComponentFactory._log.debug(String.format('Processing {0}', componentName));
    var component = eval('new ' + componentConfigurationItem.className + '();');
    component.set_childID(componentConfigurationItem.childID);
    if (placeholderId && !document.getElementById(componentName)) {
        var componentDocumentElement = document.createElement('div');
        componentDocumentElement.className = (!componentConfigurationItem.parameters['css-class']) ? 'component' : componentConfigurationItem.parameters['css-class'].toString();
        componentDocumentElement.id = componentName;
        document.getElementById(placeholderId).appendChild(componentDocumentElement);
    }
    component.get_componentLifeCycleManager().initialize(environment, String.format('autoWiring.getComponents()[\'{0}\']', componentName), componentName, componentConfigurationItem.parameters);
    return component;
}
Framework.Component.ComponentFactory.createDynamicComponent = function Framework_Component_ComponentFactory$createDynamicComponent(componentType, parent, placeholder, customComponentParameters, startComponent) {
    Framework.Component.ComponentFactory._dynamicComponentCounter++;
    var componentName = String.format('dynamic_{0}{1}', componentType.get_name(), Framework.Component.ComponentFactory._dynamicComponentCounter);
    Framework.Component.ComponentFactory._log.debug(String.format('CreateDynamicComponent {0}', componentName));
    if (!placeholder) {
        throw new Error('Error: ComponentFactory, CreateDynamicComponent => placeholder equals null');
    }
    var configuration = Framework.AbstractEnvironment.getInstance().dynamicComponentsConfiguration[componentType.get_fullName()];
    if (!configuration) {
        throw new Error(String.format('Error: ComponentFactory, CreateDynamicComponent => Configuration of component \'{0}\' doesn\'t exist', componentType.get_fullName()));
    }
    var componentParameters = Framework.Component.ComponentFactory._mergeComponentParameters(configuration.parameters, customComponentParameters);
    var component = new componentType();
    component.get_componentLifeCycleManager().set_parent(parent.get_componentLifeCycleManager());
    var componentDocumentElement = document.createElement('div');
    componentDocumentElement.className = (!componentParameters['css-class']) ? 'component' : componentParameters['css-class'].toString();
    componentDocumentElement.id = componentName;
    placeholder.appendChild(componentDocumentElement);
    component.get_componentLifeCycleManager().initialize(Framework.AbstractEnvironment.getInstance(), componentName, componentName, componentParameters);
    Framework.Component.ComponentFactory._bindServices(componentName, component, configuration.requiredServices, configuration.connectEvents, Framework.AbstractEnvironment.getInstance().services);
    if (startComponent) {
        component.get_componentLifeCycleManager().start();
    }
    return component;
}
Framework.Component.ComponentFactory.initialize = function Framework_Component_ComponentFactory$initialize(componentName, component, componentConfigurationItem, services, components) {
    Framework.Component.ComponentFactory._bindServices(componentName, component, componentConfigurationItem.requiredServices, componentConfigurationItem.connectEvents, services);
    Framework.Component.ComponentFactory._addChildComponents(component, componentConfigurationItem, components);
}
Framework.Component.ComponentFactory.deleteComponent = function Framework_Component_ComponentFactory$deleteComponent(component) {
    Framework.Component.ComponentFactory._log.debug(String.format('Deleting component {0}', component.get_componentInstanceName()));
    var configuration = Framework.AbstractEnvironment.getInstance().dynamicComponentsConfiguration[Type.getInstanceType(component).get_fullName()];
    if (!configuration) {
        throw new Error(String.format('Error: ComponentFactory, DeleteComponent => Configuration of component \'{0}\' doesn\'t exist', typeof(component)));
    }
    Framework.Component.ComponentFactory._unbindServices(component, configuration);
    Framework.AbstractEnvironment.getInstance().get_componentUpdateScheduler().removeScheduledTasksByLifeCycleManager(component.get_componentLifeCycleManager());
    component.get_componentLifeCycleManager().set_parent(null);
    component.dispose();
    component.killAllDynamicChildComponents();
    Framework.HtmlUtils.detachBehavioursAndClearHtmlElementContent(component.get_domElementId());
}
Framework.Component.ComponentFactory._unbindServices = function Framework_Component_ComponentFactory$_unbindServices(component, configuration) {
    Framework.Component.ComponentFactory._log.debug(String.format('Disconnecting services from {0}', component.get_componentInstanceName()));
    var $dict1 = configuration.connectEvents;
    for (var $key2 in $dict1) {
        var connectedEventsDictionaryEntry = { key: $key2, value: $dict1[$key2] };
        var service = Framework.AbstractEnvironment.getInstance().services[connectedEventsDictionaryEntry.key];
        var events = connectedEventsDictionaryEntry.value;
        if ((events.length === 1) && (!'*'.compareTo(events[0]))) {
        }
        else {
            var $enum3 = events.getEnumerator();
            while ($enum3.moveNext()) {
                var eventName = $enum3.get_current();
                service['unregister' + eventName + 'Listener'](component);
            }
        }
    }
}
Framework.Component.ComponentFactory._bindServices = function Framework_Component_ComponentFactory$_bindServices(componentName, component, requiredServices, connectEvents, services) {
    Framework.Component.ComponentFactory._log.debug(String.format('Connecting services to {0}', componentName));
    var $enum1 = requiredServices.getEnumerator();
    while ($enum1.moveNext()) {
        var requiredServiceName = $enum1.get_current();
        Framework.Component.ComponentFactory._log.debug(String.format('Injecting [{0}] into [{1}]', requiredServiceName, componentName));
        var requiredService = services[requiredServiceName];
        component['set' + Type.getInstanceType(requiredService).get_name()](requiredService);
    }
    Framework.Component.ComponentFactory._log.debug(String.format('Subscribing to events {0}', componentName));
    var $dict2 = connectEvents;
    for (var $key3 in $dict2) {
        var connectedEventsDictionaryEntry = { key: $key3, value: $dict2[$key3] };
        var service = services[connectedEventsDictionaryEntry.key];
        var events = connectedEventsDictionaryEntry.value;
        if ((events.length === 1) && (!'*'.compareTo(events[0]))) {
        }
        else {
            var $enum4 = events.getEnumerator();
            while ($enum4.moveNext()) {
                var eventName = $enum4.get_current();
                service['register' + eventName + 'Listener'](component);
            }
        }
    }
}
Framework.Component.ComponentFactory._addChildComponents = function Framework_Component_ComponentFactory$_addChildComponents(component, componentConfigurationItem, components) {
    var $enum1 = componentConfigurationItem.childComponents.getEnumerator();
    while ($enum1.moveNext()) {
        var childComponentName = $enum1.get_current();
        var childComponent = (components[childComponentName]);
        component.addChild(childComponent);
    }
}
Framework.Component.ComponentFactory._mergeComponentParameters = function Framework_Component_ComponentFactory$_mergeComponentParameters(parameters, newParameters) {
    if (!newParameters) {
        return parameters;
    }
    if (!parameters) {
        return newParameters;
    }
    var returnDictionary = {};
    var $dict1 = parameters;
    for (var $key2 in $dict1) {
        var newParameter = { key: $key2, value: $dict1[$key2] };
        returnDictionary[newParameter.key] = newParameter.value;
    }
    var $dict3 = newParameters;
    for (var $key4 in $dict3) {
        var newParameter = { key: $key4, value: $dict3[$key4] };
        returnDictionary[newParameter.key] = newParameter.value;
    }
    return returnDictionary;
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.AbstractXsltBasedComponent

Framework.Component.AbstractXsltBasedComponent = function Framework_Component_AbstractXsltBasedComponent() {
    Framework.Component.AbstractXsltBasedComponent.constructBase(this);
}
Framework.Component.AbstractXsltBasedComponent.prototype = {
    _parameters: null,
    
    get_componentElement: function Framework_Component_AbstractXsltBasedComponent$get_componentElement() {
        return this._environment.getDomElement(this._domElementId);
    },
    
    init: function Framework_Component_AbstractXsltBasedComponent$init(environment, componentInstanceName, domElementId, parameters) {
    },
    
    start: function Framework_Component_AbstractXsltBasedComponent$start() {
    },
    
    preTransformation: function Framework_Component_AbstractXsltBasedComponent$preTransformation(eventArgs) {
    },
    
    xmlContentReceived: function Framework_Component_AbstractXsltBasedComponent$xmlContentReceived(eventArgs) {
    },
    
    preRender: function Framework_Component_AbstractXsltBasedComponent$preRender(eventArgs) {
        Framework.Behavior.Binding.BehaviorBinder.autoBind(eventArgs.get_inMemoryContent(), this);
    },
    
    renderComplete: function Framework_Component_AbstractXsltBasedComponent$renderComplete(eventArgs) {
    },
    
    childrenUpdateComplete: function Framework_Component_AbstractXsltBasedComponent$childrenUpdateComplete(eventArgs) {
    },
    
    createComponentLifeCycleManager: function Framework_Component_AbstractXsltBasedComponent$createComponentLifeCycleManager() {
        return new Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager(this);
    },
    
    _preTransformationAbstractXsltBasedComponent: function Framework_Component_AbstractXsltBasedComponent$_preTransformationAbstractXsltBasedComponent(eventArgs) {
        if (!this.get_isComponentVisible()) {
            eventArgs.set_cancelUpdate(true);
            this.hide();
        }
        else {
            this.show();
        }
    },
    
    _preInitializeAbstractXsltBasedComponent: function Framework_Component_AbstractXsltBasedComponent$_preInitializeAbstractXsltBasedComponent(environment, componentInstanceName, domElementId, parameters) {
        Framework.Component.AbstractXsltBasedComponent.callBase(this, 'init', [ environment, componentInstanceName, domElementId, parameters ]);
        this._parameters = new Framework.CommonComponentParameters(parameters);
    },
    
    _preStartAbstractXsltBasedComponent: function Framework_Component_AbstractXsltBasedComponent$_preStartAbstractXsltBasedComponent() {
        this._log.debug('Start');
    },
    
    removeAllScheduledUpdates: function Framework_Component_AbstractXsltBasedComponent$removeAllScheduledUpdates() {
        this._environment.get_componentUpdateScheduler().removeScheduledTasksByDomain(this._domElementId);
    },
    
    getXsltParameters: function Framework_Component_AbstractXsltBasedComponent$getXsltParameters(contextObject) {
        var result = {};
        result['component-instance-name'] = this._componentInstanceName;
        result['component-dom-element-id'] = this._domElementId;
        result['culture-name'] = CultureInfo.Current.name;
        return result;
    },
    
    _getDefaultUpdateContextObject$1: function Framework_Component_AbstractXsltBasedComponent$_getDefaultUpdateContextObject$1(inilialization) {
        var region = this._environment.getRegion();
        var language = this._environment.getLanguage();
        var xsltBasedUpdateContextObject = new Framework.Component.Updating.XsltBasedUpdateContextObject(this.get_componentElement(), null, region, language, inilialization);
        xsltBasedUpdateContextObject.contentUrl = this._parameters.get_contentUrl();
        xsltBasedUpdateContextObject.xsltUrl = this._parameters.get_xsltUrl();
        xsltBasedUpdateContextObject.xsltParameters = this.getXsltParameters(null);
        return xsltBasedUpdateContextObject;
    },
    
    _initialUpdate: function Framework_Component_AbstractXsltBasedComponent$_initialUpdate() {
        var xsltBasedUpdateContextObject = this._getDefaultUpdateContextObject$1(true);
        var updateTask = new Framework.Component.Updating.UpdateXsltBasedComponentTask(xsltBasedUpdateContextObject, this.get_componentLifeCycleManager());
        updateTask.execute();
    },
    
    update: function Framework_Component_AbstractXsltBasedComponent$update(domElement, contentID, xsltUrl, xsltParameters, customEventArgs) {
        var xsltBasedUpdateContextObject;
        if (!domElement) {
            xsltBasedUpdateContextObject = this._getDefaultUpdateContextObject$1(false);
        }
        else {
            xsltBasedUpdateContextObject = new Framework.Component.Updating.XsltBasedUpdateContextObject(domElement, null, this._environment.getRegion(), this._environment.getLanguage(), false);
            xsltBasedUpdateContextObject.contentUrl = contentID;
            xsltBasedUpdateContextObject.xsltUrl = xsltUrl;
            xsltBasedUpdateContextObject.xsltParameters = xsltParameters;
        }
        xsltBasedUpdateContextObject.customEventArgs = customEventArgs;
        var updateTask = new Framework.Component.Updating.UpdateXsltBasedComponentTask(xsltBasedUpdateContextObject, this.get_componentLifeCycleManager());
        updateTask.execute();
    },
    
    periodicalUpdate: function Framework_Component_AbstractXsltBasedComponent$periodicalUpdate(domElementId, contentID, xsltUrl, xsltParameters, domain, autoRefreshPeriod, customEventArgs) {
        var xsltBasedUpdateContextObject = new Framework.Component.Updating.XsltBasedUpdateContextObject(null, domElementId, this._environment.getRegion(), this._environment.getLanguage(), false);
        xsltBasedUpdateContextObject.contentUrl = contentID;
        xsltBasedUpdateContextObject.xsltUrl = xsltUrl;
        xsltBasedUpdateContextObject.xsltParameters = xsltParameters;
        xsltBasedUpdateContextObject.customEventArgs = customEventArgs;
        var updateTask = new Framework.Component.Updating.UpdateXsltBasedComponentTask(xsltBasedUpdateContextObject, this.get_componentLifeCycleManager());
        this._environment.get_componentUpdateScheduler().scheduleNewTask(updateTask, domain, autoRefreshPeriod);
    }
}


Type.createNamespace('Framework.Component.LifeCycleManagement.EventArgs');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs

Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_ChildrenUpdateCompleteEventArgs() {
}
Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs.prototype = {
    _customEventArgs: null,
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_ChildrenUpdateCompleteEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_ChildrenUpdateCompleteEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs

Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_ChildUpdateCompleteEventArgs(updateSucceeded, childComponentInstanceName) {
    this.updateSucceeded = updateSucceeded;
    this.childComponentInstanceName = childComponentInstanceName;
}
Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs.prototype = {
    updateSucceeded: false,
    childComponentInstanceName: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs

Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs() {
}
Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs.prototype = {
    _contentXmlDocument: null,
    _customEventArgs: null,
    _cancelUpdate: false,
    
    get_contentXmlDocument: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$get_contentXmlDocument() {
        return this._contentXmlDocument;
    },
    set_contentXmlDocument: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$set_contentXmlDocument(value) {
        this._contentXmlDocument = value;
        return value;
    },
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    },
    
    get_cancelUpdate: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$get_cancelUpdate() {
        return this._cancelUpdate;
    },
    set_cancelUpdate: function Framework_Component_LifeCycleManagement_EventArgs_XmlContentReceivedEventArgs$set_cancelUpdate(value) {
        this._cancelUpdate = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs

Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_CustomEventArgs() {
    this.parametersDictionary = {};
}
Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs.prototype = {
    parametersDictionary: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs

Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs() {
}
Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs.prototype = {
    _customEventArgs: null,
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    },
    
    _domElement: null,
    
    get_domElement: function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs$get_domElement() {
        return this._domElement;
    },
    set_domElement: function Framework_Component_LifeCycleManagement_EventArgs_RenderCompleteEventArgs$set_domElement(value) {
        this._domElement = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs

Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs(inMemoryContent) {
    this._inMemoryContent = inMemoryContent;
}
Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs.prototype = {
    _inMemoryContent: null,
    _customEventArgs: null,
    
    get_inMemoryContent: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$get_inMemoryContent() {
        return this._inMemoryContent;
    },
    set_inMemoryContent: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$set_inMemoryContent(value) {
        this._inMemoryContent = value;
        return value;
    },
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$get_customEventArgs() {
        return this._customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreRenderEventArgs$set_customEventArgs(value) {
        this._customEventArgs = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs

Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs = function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs(contextObject, isPeriodicalUpdate) {
    this._isPeriodicalUpdate = isPeriodicalUpdate;
    this._contextObject = contextObject;
}
Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs.prototype = {
    _cancelUpdate: false,
    _isPeriodicalUpdate: false,
    _showIndicator: true,
    _contextObject: null,
    
    get_contextObject: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_contextObject() {
        return this._contextObject;
    },
    
    get_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_customEventArgs() {
        return this._contextObject.customEventArgs;
    },
    set_customEventArgs: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$set_customEventArgs(value) {
        this._contextObject.customEventArgs = value;
        return value;
    },
    
    get_isPeriodicalUpdate: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_isPeriodicalUpdate() {
        return this._isPeriodicalUpdate;
    },
    
    get_isInitialRender: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_isInitialRender() {
        return this._contextObject.initialRender;
    },
    
    get_cancelUpdate: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_cancelUpdate() {
        return this._cancelUpdate;
    },
    set_cancelUpdate: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$set_cancelUpdate(value) {
        this._cancelUpdate = value;
        return value;
    },
    
    get_showIndicator: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$get_showIndicator() {
        return this._showIndicator;
    },
    set_showIndicator: function Framework_Component_LifeCycleManagement_EventArgs_PreTransformationEventArgs$set_showIndicator(value) {
        this._showIndicator = value;
        return value;
    }
}


Type.createNamespace('Framework.Component.LifeCycleManagement');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.ComponentUpdateState

Framework.Component.LifeCycleManagement.ComponentUpdateState = function() { };
Framework.Component.LifeCycleManagement.ComponentUpdateState.prototype = {
    notUpdating: 0, 
    updating: 1, 
    waitingForChildren: 2
}
Framework.Component.LifeCycleManagement.ComponentUpdateState.createEnum('Framework.Component.LifeCycleManagement.ComponentUpdateState', false);


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.ComponentLifeCycleManager

Framework.Component.LifeCycleManagement.ComponentLifeCycleManager = function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager(component) {
    this._componentUpdateStatus = Framework.Component.LifeCycleManagement.ComponentUpdateState.notUpdating;
    this._component = component;
}
Framework.Component.LifeCycleManagement.ComponentLifeCycleManager.prototype = {
    _component: null,
    _environment: null,
    _childrenUpdateQueue: null,
    _parent: null,
    
    get_parent: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$get_parent() {
        return this._parent;
    },
    set_parent: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$set_parent(value) {
        this._parent = value;
        return value;
    },
    
    initialize: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$initialize(environment, componentInstanceName, domElementId, parameters) {
        this._environment = environment;
        this._component.init(environment, componentInstanceName, domElementId, parameters);
    },
    
    start: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$start() {
        this.componentUpdateStarted();
        this._component.start();
        this.componentUpdateFinished();
    },
    
    childComponentUpdateStarted: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$childComponentUpdateStarted(componentLifecycleManager) {
        if (this._componentUpdateStatus === Framework.Component.LifeCycleManagement.ComponentUpdateState.updating) {
            this._childrenUpdateQueue.add(componentLifecycleManager);
        }
    },
    
    childComponentUpdatedFinished: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$childComponentUpdatedFinished(componentLifecycleManager, updateSecceeded) {
        this._component.childComponentUpdateComplete(new Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs(updateSecceeded, componentLifecycleManager._component.get_componentInstanceName()));
        if (this._componentUpdateStatus === Framework.Component.LifeCycleManagement.ComponentUpdateState.updating || this._componentUpdateStatus === Framework.Component.LifeCycleManagement.ComponentUpdateState.waitingForChildren) {
            this._childrenUpdateQueue.remove(componentLifecycleManager);
            if (!this._childrenUpdateQueue.length) {
                this.fireChildrenUpdateCompleteEventAndLetParentKnow();
            }
        }
    },
    
    componentUpdateStarted: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$componentUpdateStarted() {
        this._componentUpdateStatus = Framework.Component.LifeCycleManagement.ComponentUpdateState.updating;
        this._childrenUpdateQueue = [];
        if (this._parent) {
            this._parent.childComponentUpdateStarted(this);
        }
    },
    
    componentUpdateFinished: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$componentUpdateFinished() {
        if (!this._childrenUpdateQueue.length) {
            this._componentUpdateStatus = Framework.Component.LifeCycleManagement.ComponentUpdateState.notUpdating;
            this.fireChildrenUpdateCompleteEventAndLetParentKnow();
        }
        else {
            this._componentUpdateStatus = Framework.Component.LifeCycleManagement.ComponentUpdateState.waitingForChildren;
        }
    },
    
    componentUpdateCanceled: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$componentUpdateCanceled() {
        this._componentUpdateStatus = Framework.Component.LifeCycleManagement.ComponentUpdateState.notUpdating;
        this._childrenUpdateQueue = [];
        if (this._parent) {
            this._parent.childComponentUpdatedFinished(this, false);
        }
    },
    
    fireChildrenUpdateCompleteEventAndLetParentKnow: function Framework_Component_LifeCycleManagement_ComponentLifeCycleManager$fireChildrenUpdateCompleteEventAndLetParentKnow() {
        var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs();
        this._component.childrenUpdateComplete(eventArgs);
        if (this._parent) {
            this._parent.childComponentUpdatedFinished(this, true);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager

Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager = function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager(component) {
    Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager.constructBase(this, [ component ]);
    this._childrenUpdateQueue = [];
}
Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager.prototype = {
    _customEventArgs$1: null,
    
    get__component$1: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$get__component$1() {
        return this._component;
    },
    
    initialize: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$initialize(environment, componentInstanceName, domElementId, parameters) {
        this._environment = environment;
        this.get__component$1()._preInitializeAbstractXsltBasedComponent(environment, componentInstanceName, domElementId, parameters);
        this.get__component$1().init(environment, componentInstanceName, domElementId, parameters);
    },
    
    start: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$start() {
        this.componentUpdateStarted();
        this.get__component$1()._preStartAbstractXsltBasedComponent();
        this.get__component$1().start();
        this.get__component$1().removeAllScheduledUpdates();
        this.get__component$1()._initialUpdate();
    },
    
    preTransformation: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$preTransformation(eventArgs) {
        (this._component)._preTransformationAbstractXsltBasedComponent(eventArgs);
        (this._component).preTransformation(eventArgs);
    },
    
    xmlContentReceived: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$xmlContentReceived(eventArgs) {
        (this._component).xmlContentReceived(eventArgs);
    },
    
    preRender: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$preRender(eventArgs) {
        (this._component).preRender(eventArgs);
    },
    
    renderComplete: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$renderComplete(eventArgs) {
        (this._component).renderComplete(eventArgs);
        this._customEventArgs$1 = eventArgs.get_customEventArgs();
        this.componentUpdateFinished();
    },
    
    fireChildrenUpdateCompleteEventAndLetParentKnow: function Framework_Component_LifeCycleManagement_XsltBasedComponentLifeCycleManager$fireChildrenUpdateCompleteEventAndLetParentKnow() {
        var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs();
        eventArgs.set_customEventArgs(this._customEventArgs$1);
        this.get__component$1().childrenUpdateComplete(eventArgs);
        if (this._parent) {
            this._parent.childComponentUpdatedFinished(this, true);
        }
    }
}


Type.createNamespace('Framework.Component.Updating');

////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.XsltBasedUpdateContextObject

Framework.Component.Updating.XsltBasedUpdateContextObject = function Framework_Component_Updating_XsltBasedUpdateContextObject(domElement, domElementId, region, language, initialRender) {
    this.domElement = domElement;
    this.domElementId = domElementId;
    this.region = region;
    this.language = language;
    this.initialRender = initialRender;
}
Framework.Component.Updating.XsltBasedUpdateContextObject.prototype = {
    domElement: null,
    domElementId: null,
    region: null,
    language: null,
    initialRender: false,
    contentUrl: null,
    xsltUrl: null,
    xsltParameters: null,
    domain: null,
    customXmlDocument: null,
    customEventArgs: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.ComponentUpdateScheduler

Framework.Component.Updating.ComponentUpdateScheduler = function Framework_Component_Updating_ComponentUpdateScheduler() {
    this._transformAndUpdateQueue = [];
}
Framework.Component.Updating.ComponentUpdateScheduler.prototype = {
    
    scheduleNewTask: function Framework_Component_Updating_ComponentUpdateScheduler$scheduleNewTask(task, domain, autoRefreshPeriod) {
        if (!task) {
            return;
        }
        task.set_isPeriodical(true);
        task.set_autoRefreshPeriod(autoRefreshPeriod);
        task.set_domain(domain);
        task.execute();
        this._transformAndUpdateQueue.add(task);
    },
    
    removeScheduledTasksByDomain: function Framework_Component_Updating_ComponentUpdateScheduler$removeScheduledTasksByDomain(domain) {
        Framework.Component.Updating.ComponentUpdateScheduler._log.debug(String.format('RemoveScheduledTasksByDomain domain=[{0}]', domain));
        var newQueue = [];
        for (var i = 0; i < this._transformAndUpdateQueue.length; i++) {
            if (domain !== (this._transformAndUpdateQueue[i]).get_domain()) {
                newQueue.add(this._transformAndUpdateQueue[i]);
            }
        }
        this._transformAndUpdateQueue = newQueue;
    },
    
    removeScheduledTasksByLifeCycleManager: function Framework_Component_Updating_ComponentUpdateScheduler$removeScheduledTasksByLifeCycleManager(manager) {
        Framework.Component.Updating.ComponentUpdateScheduler._log.debug('RemoveScheduledTasksByLifeCycleManager');
        var newQueue = [];
        for (var i = 0; i < this._transformAndUpdateQueue.length; i++) {
            if (manager !== (this._transformAndUpdateQueue[i]).get_lifeCycleManager()) {
                newQueue.add(this._transformAndUpdateQueue[i]);
            }
        }
        this._transformAndUpdateQueue = newQueue;
    },
    
    runSchedulingRuntime: function Framework_Component_Updating_ComponentUpdateScheduler$runSchedulingRuntime(startIndex) {
        var queue = this._transformAndUpdateQueue;
        Framework.Component.Updating.ComponentUpdateScheduler._log.debug(String.format('RunSchedulingRuntime woke up!, StartIndex=[{0}]', startIndex));
        if (queue && queue.length > 0) {
            startIndex = Math.min(startIndex, queue.length - 1);
            var i = startIndex;
            do {
                var currentTask = queue[i];
                Framework.Component.Updating.ComponentUpdateScheduler._log.debug(String.format('RunSchedulingRuntime processing task i=[{0}] LastExecuted=[{1}] AutoRefreshPeriod=[{2}]', i, currentTask.get_lastExecuted(), currentTask.get_autoRefreshPeriod()));
                i = (i + 1) % queue.length;
                if (currentTask.get_lastExecuted().getTime() + currentTask.get_autoRefreshPeriod() < Date.get_now().getTime()) {
                    currentTask.execute();
                    break;
                }
            } while (i !== startIndex);
            startIndex = i;
        }
        window.setTimeout(Delegate.create(this, function() {
            this.runSchedulingRuntime(startIndex);
        }), Framework.Parameters.transformAndUpdateSchedulerPeriod);
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.UpdateXsltBasedComponentTask

Framework.Component.Updating.UpdateXsltBasedComponentTask = function Framework_Component_Updating_UpdateXsltBasedComponentTask(contextObject, lifeCycleManager) {
    this._contextObject = contextObject;
    this._contextObject.contentUrl = this._createRealUrl(this._contextObject.contentUrl);
    this._lifeCycleManager = lifeCycleManager;
    this._lastExecuted = Date.get_now();
}
Framework.Component.Updating.UpdateXsltBasedComponentTask._onContentRequestsComplete = function Framework_Component_Updating_UpdateXsltBasedComponentTask$_onContentRequestsComplete(contentUrl) {
    Framework.Component.Updating.UpdateXsltBasedComponentTask._log.debug(String.format('OnContentRequestsComplete contentUrl=[{0}]', contentUrl));
    if (Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks, contentUrl) && Object.getKeyCount((Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[contentUrl])) > 0) {
        var xmlCallBacksForUrl = Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[contentUrl];
        var $dict1 = xmlCallBacksForUrl;
        for (var $key2 in $dict1) {
            var callback = { key: $key2, value: $dict1[$key2] };
            Framework.Component.Updating.UpdateXsltBasedComponentTask._log.debug(String.format('OnContentRequestsComplete callback key=[{0}] contentUrl=[{1}]', callback.key, contentUrl));
            (callback.value).invoke();
        }
    }
}
Framework.Component.Updating.UpdateXsltBasedComponentTask._getStamp = function Framework_Component_Updating_UpdateXsltBasedComponentTask$_getStamp(domElementId) {
    return Framework.Component.Updating.UpdateXsltBasedComponentTask._domElementCounterMap[domElementId];
}
Framework.Component.Updating.UpdateXsltBasedComponentTask._setStamp = function Framework_Component_Updating_UpdateXsltBasedComponentTask$_setStamp(domElementId, value) {
    Framework.Component.Updating.UpdateXsltBasedComponentTask._domElementCounterMap[domElementId] = value;
}
Framework.Component.Updating.UpdateXsltBasedComponentTask.storeXsltDocument = function Framework_Component_Updating_UpdateXsltBasedComponentTask$storeXsltDocument(url, document) {
    Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument[url] = document;
}
Framework.Component.Updating.UpdateXsltBasedComponentTask.prototype = {
    _isPeriodical: false,
    _autoRefreshPeriod: null,
    _domain: null,
    _startingCounterValue: 0,
    _lastExecuted: null,
    _contentRequest: null,
    _xsltRequest: null,
    _contentXmlDocument: null,
    _xsltXmlDocument: null,
    _sdcToken: null,
    _contextObject: null,
    _lifeCycleManager: null,
    
    get_lifeCycleManager: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_lifeCycleManager() {
        return this._lifeCycleManager;
    },
    
    get_isPeriodical: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_isPeriodical() {
        return this._isPeriodical;
    },
    set_isPeriodical: function Framework_Component_Updating_UpdateXsltBasedComponentTask$set_isPeriodical(value) {
        this._isPeriodical = value;
        return value;
    },
    
    get_autoRefreshPeriod: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_autoRefreshPeriod() {
        return this._autoRefreshPeriod;
    },
    set_autoRefreshPeriod: function Framework_Component_Updating_UpdateXsltBasedComponentTask$set_autoRefreshPeriod(value) {
        this._autoRefreshPeriod = value;
        return value;
    },
    
    get_domain: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_domain() {
        return this._domain;
    },
    set_domain: function Framework_Component_Updating_UpdateXsltBasedComponentTask$set_domain(value) {
        this._domain = value;
        return value;
    },
    
    get_lastExecuted: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_lastExecuted() {
        return this._lastExecuted;
    },
    
    get__contentUrl: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get__contentUrl() {
        return this._createRealUrl(this._contextObject.contentUrl);
    },
    
    get_domElementId: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_domElementId() {
        return (this.get_isPeriodical()) ? this._contextObject.domElementId : this._contextObject.domElement.id;
    },
    
    get_domElement: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get_domElement() {
        return (this.get_isPeriodical()) ? document.getElementById(this._contextObject.domElementId) : this._contextObject.domElement;
    },
    
    get__xsltUrl: function Framework_Component_Updating_UpdateXsltBasedComponentTask$get__xsltUrl() {
        return this._contextObject.xsltUrl;
    },
    
    execute: function Framework_Component_Updating_UpdateXsltBasedComponentTask$execute() {
        if (!this._contextObject.initialRender) {
            this._lifeCycleManager.componentUpdateStarted();
        }
        var preTransformationEventArgs = new Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs(this._contextObject, this.get_isPeriodical());
        this._lifeCycleManager.preTransformation(preTransformationEventArgs);
        if (preTransformationEventArgs.get_cancelUpdate()) {
            this._lifeCycleManager.componentUpdateCanceled();
            return;
        }
        this._sdcToken = Framework.SDC.SDCManager.sdcManagerInstance().startRenderLog(this.get_domElementId());
        if (preTransformationEventArgs.get_showIndicator()) {
            Framework.Component.Updating.HtmlUpdater.updateDomElementDirect(document.getElementById(this.get_domElementId()), '<img src=\'/indicator.gif\' />');
        }
        this._lastExecuted = Date.get_now();
        this._contentXmlDocument = this._contextObject.customXmlDocument;
        this._update(true);
    },
    
    _update: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_update(appendTimestampToContentUrl) {
        this._startingCounterValue = Framework.Component.Updating.UpdateXsltBasedComponentTask._requestCounter++;
        Framework.Component.Updating.UpdateXsltBasedComponentTask._setStamp(this.get_domElementId(), this._startingCounterValue);
        if (!this._contentXmlDocument) {
            if (this.get__contentUrl()) {
                var doCall = false;
                if (!Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks, this.get__contentUrl()) || !Object.getKeyCount((Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()]))) {
                    doCall = true;
                    Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()] = {};
                }
                (Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()])[this.get_domElementId()] = Delegate.create(this, this._onContentRequestComplete);
                if (doCall) {
                    this._contentXmlDocument = null;
                    this._contentRequest = new Framework.XMLHttpRequestDecorator();
                    this._contentRequest.onreadystatechange = Delegate.create(this, function() {
                        Framework.Component.Updating.UpdateXsltBasedComponentTask._onContentRequestsComplete(this.get__contentUrl());
                    });
                    this._contentRequest.open('GET', this.get__contentUrl(), true);
                    this._contentRequest.send(null);
                    Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests[this.get__contentUrl()] = this._contentRequest;
                }
            }
            else {
                this._contentXmlDocument = Framework.XMLUtils.get_emptyContentDocument();
            }
        }
        if (!Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument, this.get__xsltUrl())) {
            this._xsltRequest = new Framework.XMLHttpRequestDecorator();
            this._xsltRequest.onreadystatechange = Delegate.create(this, this._onXsltRequestComplete);
            this._xsltRequest.open('GET', this.get__xsltUrl(), true);
            this._xsltRequest.send(null);
        }
        else {
            this._xsltXmlDocument = Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument[this.get__xsltUrl()];
        }
        this._tryTransform();
    },
    
    _onContentRequestComplete: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_onContentRequestComplete() {
        if (!this._contentRequest) {
            this._contentRequest = Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests[this.get__contentUrl()];
        }
        if (this._contentRequest) {
            if (this._contentRequest.readyState === 4) {
                if (this._contentRequest.status === 200 || this._contentRequest.status === 304) {
                    var xmlContentReceivedEventArgs = new Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs();
                    xmlContentReceivedEventArgs.set_contentXmlDocument(this._contentRequest.responseXML);
                    xmlContentReceivedEventArgs.set_customEventArgs(this._contextObject.customEventArgs);
                    this._lifeCycleManager.xmlContentReceived(xmlContentReceivedEventArgs);
                    if (xmlContentReceivedEventArgs.get_cancelUpdate()) {
                        this._contentXmlDocument = null;
                        this._lifeCycleManager.componentUpdateCanceled();
                        return;
                    }
                    this._contentXmlDocument = xmlContentReceivedEventArgs.get_contentXmlDocument();
                    this._tryTransform();
                }
                else {
                    Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.operationalException);
                    Framework.Component.Updating.HtmlUpdater.updateDomElement(this.get_domElement(), '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
                }
                if (Object.keyExists(Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks, this.get__contentUrl()) && Object.getKeyCount((Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()])) > 0) {
                    var xmlCallBack = Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks[this.get__contentUrl()];
                    if (Object.keyExists(xmlCallBack, this.get_domElementId())) {
                        delete xmlCallBack[this.get_domElementId()];
                    }
                    if (!Object.getKeyCount(xmlCallBack)) {
                        delete Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests[this.get__contentUrl()];
                        this._contentRequest.onreadystatechange = null;
                    }
                }
            }
        }
    },
    
    _onXsltRequestComplete: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_onXsltRequestComplete() {
        if (this._xsltRequest.readyState === 4) {
            if (this._xsltRequest.status === 200 || this._xsltRequest.status === 304) {
                this._xsltXmlDocument = this._xsltRequest.responseXML;
                Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument[this.get__xsltUrl()] = this._xsltXmlDocument;
                this._tryTransform();
                if (this._xsltRequest) {
                    this._xsltRequest.onreadystatechange = null;
                }
            }
            else {
                Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.operationalException);
                Framework.Component.Updating.HtmlUpdater.updateDomElement(this.get_domElement(), '<img src=\'..\\..\\..\\error.png\' alt=\'error\' />');
            }
        }
    },
    
    _tryTransform: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_tryTransform() {
        Framework.Component.Updating.UpdateXsltBasedComponentTask._log.debug(String.format('TryTransform domElementId=[{0}] contentUrl=[{1}]', this.get_domElementId(), this.get__contentUrl()));
        if (this._contentXmlDocument && this._xsltXmlDocument && this._startingCounterValue === Framework.Component.Updating.UpdateXsltBasedComponentTask._getStamp(this.get_domElementId())) {
            Framework.XMLUtils.transformAndUpdate(this._contentXmlDocument, this._xsltXmlDocument, this._contextObject.xsltParameters, this.get_domElementId(), this.get_domElement(), Delegate.create(this, this._decoratePreRenderEventCallback));
            if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.mozilla) {
                var css = '#' + this.get_domElementId() + ' .escapedHtml';
                var elements = Framework.DocumentFinder.getElementsBySelector(css);
                if (elements) {
                    for (var i = 0; i < elements.length; i++) {
                        elements[i].innerHTML = elements[i].innerText;
                    }
                }
            }
            Framework.SDC.SDCManager.sdcManagerInstance().endRenderLog(this._sdcToken, Framework.SDC.SDCExceptionType.noException);
            window.setTimeout(Delegate.create(this, function() {
                var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs();
                eventArgs.set_domElement(this.get_domElement());
                eventArgs.set_customEventArgs(this._contextObject.customEventArgs);
                this._lifeCycleManager.renderComplete(eventArgs);
            }), 0);
        }
    },
    
    _decoratePreRenderEventCallback: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_decoratePreRenderEventCallback(inMemoryContent) {
        var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs(inMemoryContent);
        eventArgs.set_customEventArgs(this._contextObject.customEventArgs);
        this._lifeCycleManager.preRender(eventArgs);
    },
    
    _createRealUrl: function Framework_Component_Updating_UpdateXsltBasedComponentTask$_createRealUrl(url) {
        return ((!url) ? null : url.replace('${region}', this._contextObject.region).replace('${language}', this._contextObject.language));
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Component.Updating.HtmlUpdater

Framework.Component.Updating.HtmlUpdater = function Framework_Component_Updating_HtmlUpdater() {
}
Framework.Component.Updating.HtmlUpdater.updateDomElement = function Framework_Component_Updating_HtmlUpdater$updateDomElement(domElement, htmlContent) {
    if (domElement) {
        Framework.Component.Updating.HtmlUpdater.safeUpdateDomElementDirect(domElement, htmlContent);
    }
    else {
        Framework.Component.Updating.HtmlUpdater._log.debug('Environment.UpdateDomElement Error - Dom element is null');
    }
}
Framework.Component.Updating.HtmlUpdater.updateDomElementById = function Framework_Component_Updating_HtmlUpdater$updateDomElementById(domElementId, htmlContent) {
    Framework.Component.Updating.HtmlUpdater.updateDomElement(document.getElementById(domElementId), htmlContent);
}
Framework.Component.Updating.HtmlUpdater.updateDomElementDirect = function Framework_Component_Updating_HtmlUpdater$updateDomElementDirect(domElement, htmlContent) {
    Framework.Component.Updating.HtmlUpdater.safeUpdateDomElementDirect(domElement, htmlContent);
}
Framework.Component.Updating.HtmlUpdater.safeUpdateDomElement = function Framework_Component_Updating_HtmlUpdater$safeUpdateDomElement(domElementId, htmlContent) {
    var domElement = document.getElementById(domElementId);
    if (domElement) {
        Framework.Component.Updating.HtmlUpdater.safeUpdateDomElementDirect(domElement, htmlContent);
    }
    else {
        Framework.Component.Updating.HtmlUpdater._log.debug(String.format('Environment.UpdateDomElement Error - Dom element id [{0}] does not exist', domElementId));
    }
}
Framework.Component.Updating.HtmlUpdater.safeUpdateDomElementDirect = function Framework_Component_Updating_HtmlUpdater$safeUpdateDomElementDirect(domElement, htmlContent) {
    if (!domElement) {
        return;
    }
    if (domElement.innerHTML === htmlContent) {
        Framework.Component.Updating.HtmlUpdater._log.debug(domElement.id + '.InnerHTML unchanged - not updated');
    }
    else {
        Framework.DocumentEvents.purgeEventsBeforeUpdate(domElement, true, 0);
        domElement.innerHTML = htmlContent;
    }
}


Type.createNamespace('Framework.SDC');

////////////////////////////////////////////////////////////////////////////////
// Framework.SDC.SDCManager

Framework.SDC.SDCManager = function Framework_SDC_SDCManager() {
    this._isConfigLoaded = false;
    this._initialiseStatisticAndConfigDictionaries();
    this._isCurrentlySendingBatch = false;
    this._failedBatchSendAttempts = 0;
}
Framework.SDC.SDCManager.initializeSDCManager = function Framework_SDC_SDCManager$initializeSDCManager() {
    Framework.SDC.SDCManager._singletonSDCManager = new Framework.SDC.SDCManager();
    Framework.SDC.SDCManager._singletonSDCManager.fetchConfiguration();
}
Framework.SDC.SDCManager.sdcManagerInstance = function Framework_SDC_SDCManager$sdcManagerInstance() {
    return Framework.SDC.SDCManager._singletonSDCManager;
}
Framework.SDC.SDCManager.prototype = {
    _isSDCLoggingOn: false,
    _intervalID: 0,
    _statistics: null,
    _config: null,
    _isConfigLoaded: false,
    _isCurrentlySendingBatch: false,
    _failedBatchSendAttempts: 0,
    
    fetchConfiguration: function Framework_SDC_SDCManager$fetchConfiguration() {
        if (!this._isSDCLoggingOn) {
            return;
        }
        if (this._getTotalConfigCount() > 0) {
            return;
        }
        Framework.AbstractEnvironment.getInstance().invokeAsync(Framework.SDC.SDCManager._serviceName, 'GetConfiguration', {}, Delegate.create(this, function(result) {
            var config = result;
            if (config) {
                var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
                while ($enum1.moveNext()) {
                    var statType = $enum1.get_current();
                    if (Object.keyExists(config, statType.toString())) {
                        this._loadConfiguration(statType, false, config[statType.toString()]);
                    }
                    if (Object.keyExists(config, String.format('{0}{1}', Framework.SDC.SDCManager._priorityKeyPrefix, statType))) {
                        this._loadConfiguration(statType, true, config[String.format('{0}{1}', Framework.SDC.SDCManager._priorityKeyPrefix, statType)]);
                    }
                }
            }
            if (!this._getTotalConfigCount()) {
                this._isSDCLoggingOn = false;
            }
            this._isConfigLoaded = true;
            this._filterCurrentStatistics();
            if (this._getTotalConfigCount() > 0) {
                this._intervalID = window.setInterval(Delegate.create(this, this._prepareBatch), Framework.SDC.SDCManager._timeoutInterval);
            }
        }), Delegate.create(this, function(exception) {
            this._isSDCLoggingOn = false;
            this._filterCurrentStatistics();
        }));
    },
    
    startRenderLog: function Framework_SDC_SDCManager$startRenderLog(domElementID) {
        if (!this._isSDCLoggingOn) {
            return Framework.SDC.SDCManager.notLoggedInternalToken;
        }
        var componentInstance = new RegExp('^([A-Za-z]*)[0-9]*').exec(domElementID);
        if (componentInstance.length === 2 && Object.keyExists(Framework.AbstractEnvironment.getInstance().components, componentInstance[0])) {
            var componentInstanceID = componentInstance[0];
            var javascriptClass = Type.getInstanceType((Framework.AbstractEnvironment.getInstance().components[componentInstanceID])).get_fullName().toString();
            var internalToken = this._generateInternalToken(Framework.SDC.SDCStatisticType.render, javascriptClass);
            if (internalToken !== Framework.SDC.SDCManager.notLoggedInternalToken) {
                var statistic = new Framework.SDC.SDCStatistic(internalToken, Framework.SDC.SDCStatisticType.render, javascriptClass, this._getIDFWSDCObject(Framework.SDC.SDCStatisticType.render, javascriptClass));
                statistic.beginStatisticLogging();
                this._getStatisticDictionary(Framework.SDC.SDCStatisticType.render)[internalToken] = statistic;
                return internalToken;
            }
        }
        return Framework.SDC.SDCManager.notLoggedInternalToken;
    },
    
    endRenderLog: function Framework_SDC_SDCManager$endRenderLog(internalToken, exception) {
        if (internalToken !== Framework.SDC.SDCManager.notLoggedInternalToken && Object.keyExists(this._getStatisticDictionary(Framework.SDC.SDCStatisticType.render), internalToken)) {
            this._getStatistic(Framework.SDC.SDCStatisticType.render, internalToken).endStatisticLogging('', exception);
            this._checkForPriorityLogging(this._getStatistic(Framework.SDC.SDCStatisticType.render, internalToken));
        }
    },
    
    startRPCLog: function Framework_SDC_SDCManager$startRPCLog(serviceName, methodName) {
        if (!this._isSDCLoggingOn) {
            return Framework.SDC.SDCManager.notLoggedInternalToken;
        }
        var statisticName = String.format('{0}.{1}', serviceName, methodName);
        var internalToken = this._generateInternalToken(Framework.SDC.SDCStatisticType.RPC, statisticName);
        if (internalToken !== Framework.SDC.SDCManager.notLoggedInternalToken) {
            var statistic = new Framework.SDC.SDCStatistic(internalToken, Framework.SDC.SDCStatisticType.RPC, statisticName, this._getIDFWSDCObject(Framework.SDC.SDCStatisticType.RPC, statisticName));
            statistic.beginStatisticLogging();
            this._getStatisticDictionary(Framework.SDC.SDCStatisticType.RPC)[internalToken] = statistic;
        }
        return internalToken;
    },
    
    endRPCLog: function Framework_SDC_SDCManager$endRPCLog(internalToken, serverToken, exception) {
        if (internalToken !== Framework.SDC.SDCManager.notLoggedInternalToken && Object.keyExists(this._getStatisticDictionary(Framework.SDC.SDCStatisticType.RPC), internalToken)) {
            this._getStatistic(Framework.SDC.SDCStatisticType.RPC, internalToken).endStatisticLogging(serverToken, exception);
            this._checkForPriorityLogging(this._getStatistic(Framework.SDC.SDCStatisticType.RPC, internalToken));
        }
    },
    
    endMultiplexRPCLog: function Framework_SDC_SDCManager$endMultiplexRPCLog(internalToken, serverToken, exception, endTime) {
        if (internalToken !== Framework.SDC.SDCManager.notLoggedInternalToken && Object.keyExists(this._getStatisticDictionary(Framework.SDC.SDCStatisticType.RPC), internalToken)) {
            this._getStatistic(Framework.SDC.SDCStatisticType.RPC, internalToken).endStatisticLogging(serverToken, exception, endTime);
            this._checkForPriorityLogging(this._getStatistic(Framework.SDC.SDCStatisticType.RPC, internalToken));
        }
    },
    
    abortRPCLog: function Framework_SDC_SDCManager$abortRPCLog(internalToken) {
        delete this._getStatisticDictionary(Framework.SDC.SDCStatisticType.RPC)[internalToken];
    },
    
    _prepareBatch: function Framework_SDC_SDCManager$_prepareBatch() {
        this._clearOldStatistics();
        if (!this._isCurrentlySendingBatch && this._getTotalStatisticCount() >= Framework.SDC.SDCManager._minimumBatchSize) {
            var batchStatistics = [];
            var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
            while ($enum1.moveNext()) {
                var statType = $enum1.get_current();
                var $dict2 = this._getStatisticDictionary(statType);
                for (var $key3 in $dict2) {
                    var entry = { key: $key3, value: $dict2[$key3] };
                    if (batchStatistics.length >= Framework.SDC.SDCManager._maximumBatchSize) {
                        break;
                    }
                    var stat = entry.value;
                    if (stat.isFinishedLogging()) {
                        batchStatistics.add(stat);
                    }
                }
            }
            if (batchStatistics.length >= Framework.SDC.SDCManager._minimumBatchSize) {
                this._sendBatch(batchStatistics, false);
            }
            else {
                this._isCurrentlySendingBatch = false;
            }
        }
    },
    
    _sendBatch: function Framework_SDC_SDCManager$_sendBatch(batchStatistics, isPrioritySend) {
        var batch = [];
        var $enum1 = batchStatistics.getEnumerator();
        while ($enum1.moveNext()) {
            var stat = $enum1.get_current();
            batch.add(stat.serializeStatistic());
        }
        this._isCurrentlySendingBatch = true;
        Framework.AbstractEnvironment.getInstance().invokeAsync(Framework.SDC.SDCManager._serviceName, 'LogStatisticBatch', { stats: batch }, Delegate.create(this, function(result) {
            for (var i = 0; i < batchStatistics.length; i++) {
                var stat = batchStatistics[i];
                delete this._getStatisticDictionary(stat.get_type())[stat.get_internalToken()];
            }
            this._failedBatchSendAttempts = 0;
            if (!isPrioritySend) {
                this._isCurrentlySendingBatch = false;
            }
        }), Delegate.create(this, function(exception) {
            this._failedBatchSendAttempts++;
            if (!isPrioritySend) {
                this._isCurrentlySendingBatch = false;
            }
            if (this._failedBatchSendAttempts > Framework.SDC.SDCManager._maxFailedBatchSendAttempts) {
                this._isSDCLoggingOn = false;
                this._filterCurrentStatistics();
            }
        }));
    },
    
    _checkIfNeedsLogging: function Framework_SDC_SDCManager$_checkIfNeedsLogging(statisticType, statisticName) {
        if (!this._isSDCLoggingOn) {
            return false;
        }
        else if (!this._isConfigLoaded) {
            return true;
        }
        else {
            return Object.keyExists(this._getConfigDictionary(statisticType), statisticName);
        }
    },
    
    _generateInternalToken: function Framework_SDC_SDCManager$_generateInternalToken(statisticType, statisticName) {
        if (this._checkIfNeedsLogging(statisticType, statisticName)) {
            var statistics = this._getStatisticDictionary(statisticType);
            var internalToken = String.format('{0}.{1}', Date.get_now().getTime(), statisticName.substr(0, 6));
            var safteyCounter = 0;
            while (Object.keyExists(statistics, internalToken) && safteyCounter < 15) {
                internalToken += Math.truncate(Math.floor(Math.random() * 1001));
                safteyCounter++;
            }
            if (!Object.keyExists(statistics, internalToken)) {
                return internalToken;
            }
        }
        return Framework.SDC.SDCManager.notLoggedInternalToken;
    },
    
    _filterCurrentStatistics: function Framework_SDC_SDCManager$_filterCurrentStatistics() {
        if (!this._isSDCLoggingOn) {
            this._initialiseStatisticAndConfigDictionaries();
        }
        else {
            var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
            while ($enum1.moveNext()) {
                var statType = $enum1.get_current();
                var removeInternalTokens = [];
                var $dict2 = this._getStatisticDictionary(statType);
                for (var $key3 in $dict2) {
                    var entry = { key: $key3, value: $dict2[$key3] };
                    var stat = entry.value;
                    stat.setIDFWSDCObject(this._getIDFWSDCObject(statType, stat.get_statisticName()));
                    if (!this._checkIfNeedsLogging(statType, stat.get_statisticName())) {
                        removeInternalTokens.add(entry.key);
                    }
                }
                var $enum4 = removeInternalTokens.getEnumerator();
                while ($enum4.moveNext()) {
                    var internalToken = $enum4.get_current();
                    delete this._getStatisticDictionary(statType)[internalToken];
                }
            }
        }
    },
    
    _loadConfiguration: function Framework_SDC_SDCManager$_loadConfiguration(statisticType, isPriority, configs) {
        var config = this._getConfigDictionary(statisticType);
        var $dict1 = configs;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            config[entry.key] = new Framework.SDC.SDCConfig(isPriority, entry.value);
        }
    },
    
    _checkForPriorityLogging: function Framework_SDC_SDCManager$_checkForPriorityLogging(stat) {
        if (Object.keyExists(this._getConfigDictionary(stat.get_type()), stat.get_statisticName()) && (this._getConfigDictionary(stat.get_type())[stat.get_statisticName()]).isPriority) {
            this._sendBatch([ stat ], true);
        }
    },
    
    _getConfigDictionary: function Framework_SDC_SDCManager$_getConfigDictionary(statisticType) {
        if (Object.keyExists(this._config, statisticType.toString())) {
            return this._config[statisticType.toString()];
        }
        else {
            return {};
        }
    },
    
    _getIDFWSDCObject: function Framework_SDC_SDCManager$_getIDFWSDCObject(statisticType, statisticName) {
        var config = this._getConfigDictionary(statisticType);
        if (Object.keyExists(config, statisticName)) {
            return (config[statisticName]).idfwsdcObject;
        }
        else {
            return -1;
        }
    },
    
    _getStatisticDictionary: function Framework_SDC_SDCManager$_getStatisticDictionary(statisticType) {
        if (Object.keyExists(this._statistics, statisticType.toString())) {
            return this._statistics[statisticType.toString()];
        }
        else {
            return {};
        }
    },
    
    _getStatistic: function Framework_SDC_SDCManager$_getStatistic(statisticType, internalToken) {
        return this._getStatisticDictionary(statisticType)[internalToken];
    },
    
    _getTotalStatisticCount: function Framework_SDC_SDCManager$_getTotalStatisticCount() {
        var total = 0;
        var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var statType = $enum1.get_current();
            total += Object.getKeyCount(this._getStatisticDictionary(statType));
        }
        return total;
    },
    
    _getTotalConfigCount: function Framework_SDC_SDCManager$_getTotalConfigCount() {
        var total = 0;
        var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var statType = $enum1.get_current();
            total += Object.getKeyCount(this._getConfigDictionary(statType));
        }
        return total;
    },
    
    _initialiseStatisticAndConfigDictionaries: function Framework_SDC_SDCManager$_initialiseStatisticAndConfigDictionaries() {
        this._statistics = {};
        this._config = {};
        var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var statType = $enum1.get_current();
            this._statistics[statType.toString()] = {};
            this._config[statType.toString()] = {};
        }
    },
    
    _clearOldStatistics: function Framework_SDC_SDCManager$_clearOldStatistics() {
        var $enum1 = Framework.SDC.SDCStatisticType.sdcStatisticTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var statType = $enum1.get_current();
            var removalList = [];
            var $dict2 = this._getStatisticDictionary(statType);
            for (var $key3 in $dict2) {
                var entry = { key: $key3, value: $dict2[$key3] };
                var stat = entry.value;
                if (!stat.isFinishedLogging() && (Date.get_now().getTime() - stat.get_startTime()) > 500000) {
                    removalList.add(stat.get_internalToken());
                }
            }
            var $enum4 = removalList.getEnumerator();
            while ($enum4.moveNext()) {
                var token = $enum4.get_current();
                delete this._getStatisticDictionary(statType)[token];
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.SDC.SDCStatistic

Framework.SDC.SDCStatistic = function Framework_SDC_SDCStatistic(internalToken, statisticType, statisticName, idFWSDCObject) {
    this._internalToken = internalToken;
    this._type = statisticType;
    this._name = statisticName;
    this._idFWSDCObject = idFWSDCObject;
    this._startTime = 0;
    this._endTime = 0;
    this._duration = 0;
    this._exceptionType = Framework.SDC.SDCExceptionType.noException;
}
Framework.SDC.SDCStatistic.prototype = {
    _type: 0,
    
    get_type: function Framework_SDC_SDCStatistic$get_type() {
        return this._type;
    },
    
    _idFWSDCObject: null,
    _trackingToken: null,
    _exceptionType: 0,
    _duration: 0,
    _name: null,
    
    get_statisticName: function Framework_SDC_SDCStatistic$get_statisticName() {
        return this._name;
    },
    
    _internalToken: null,
    
    get_internalToken: function Framework_SDC_SDCStatistic$get_internalToken() {
        return this._internalToken;
    },
    
    _startTime: 0,
    
    get_startTime: function Framework_SDC_SDCStatistic$get_startTime() {
        return this._startTime;
    },
    
    _endTime: 0,
    
    beginStatisticLogging: function Framework_SDC_SDCStatistic$beginStatisticLogging() {
        this._startTime = Date.get_now().getTime();
    },
    
    endStatisticLogging: function Framework_SDC_SDCStatistic$endStatisticLogging(trackingToken, exception, endTime) {
        this._endTime = (endTime) ? endTime : Date.get_now().getTime();
        this._duration = this._endTime - this._startTime;
        this._trackingToken = trackingToken;
        this._exceptionType = exception;
    },
    
    isFinishedLogging: function Framework_SDC_SDCStatistic$isFinishedLogging() {
        return this._duration > 0;
    },
    
    serializeStatistic: function Framework_SDC_SDCStatistic$serializeStatistic() {
        return { Type: this._type, IDFWSDCObject: this._idFWSDCObject, TrackingToken: this._trackingToken, ExceptionType: this._exceptionType, Duration: this._duration };
    },
    
    setIDFWSDCObject: function Framework_SDC_SDCStatistic$setIDFWSDCObject(idFWSDCObject) {
        this._idFWSDCObject = idFWSDCObject;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.SDC.SDCStatisticType

Framework.SDC.SDCStatisticType = function Framework_SDC_SDCStatisticType() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.SDC.SDCExceptionType

Framework.SDC.SDCExceptionType = function Framework_SDC_SDCExceptionType() {
}


////////////////////////////////////////////////////////////////////////////////
// Framework.SDC.SDCConfig

Framework.SDC.SDCConfig = function Framework_SDC_SDCConfig(isPriority, IDFWSDCObject) {
    this.isPriority = isPriority;
    this.idfwsdcObject = IDFWSDCObject;
}
Framework.SDC.SDCConfig.prototype = {
    isPriority: false,
    idfwsdcObject: null
}


Type.createNamespace('Framework.Util');

////////////////////////////////////////////////////////////////////////////////
// Framework.Util.TypeInfoProvider

Framework.Util.TypeInfoProvider = function Framework_Util_TypeInfoProvider() {
}
Framework.Util.TypeInfoProvider.isDerivedFrom = function Framework_Util_TypeInfoProvider$isDerivedFrom(source, type) {
    while ((source !== type) && (source)) {
        source = source.get_baseType();
    }
    return (source === type);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Util.StringConverter

Framework.Util.StringConverter = function Framework_Util_StringConverter() {
}
Framework.Util.StringConverter.getAsInt32 = function Framework_Util_StringConverter$getAsInt32(data) {
    return eval(data);
}
Framework.Util.StringConverter.getAsNumber = function Framework_Util_StringConverter$getAsNumber(data) {
    return eval(data);
}
Framework.Util.StringConverter.getAsString = function Framework_Util_StringConverter$getAsString(data) {
    return data;
}
Framework.Util.StringConverter.getAsStringArray = function Framework_Util_StringConverter$getAsStringArray(data) {
    return eval(data);
}
Framework.Util.StringConverter.getAsNumberArray = function Framework_Util_StringConverter$getAsNumberArray(data) {
    return eval(data);
}
Framework.Util.StringConverter.getAsBoolean = function Framework_Util_StringConverter$getAsBoolean(data) {
    return eval(data);
}
Framework.Util.StringConverter.getAsEscapedString = function Framework_Util_StringConverter$getAsEscapedString(data) {
    return (isNullOrUndefined(data)) ? data : escape(data);
}
Framework.Util.StringConverter.getAsDictionary = function Framework_Util_StringConverter$getAsDictionary(data) {
    return eval('(' + data + ')');
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Util.DOMElementAttributeProvider

Framework.Util.DOMElementAttributeProvider = function Framework_Util_DOMElementAttributeProvider(domElement) {
    this._domElement = domElement;
}
Framework.Util.DOMElementAttributeProvider.prototype = {
    _domElement: null,
    
    getAttributeAsNumber: function Framework_Util_DOMElementAttributeProvider$getAttributeAsNumber(attributeName) {
        return Framework.Util.StringConverter.getAsNumber(this._domElement.getAttribute(attributeName));
    },
    
    getAttributeAsString: function Framework_Util_DOMElementAttributeProvider$getAttributeAsString(attributeName) {
        return this._domElement.getAttribute(attributeName);
    },
    
    getAttributeAsStringArray: function Framework_Util_DOMElementAttributeProvider$getAttributeAsStringArray(attributeName) {
        return Framework.Util.StringConverter.getAsStringArray(this._domElement.getAttribute(attributeName));
    },
    
    getAttributeAsNumberArray: function Framework_Util_DOMElementAttributeProvider$getAttributeAsNumberArray(attributeName) {
        return Framework.Util.StringConverter.getAsNumberArray(this._domElement.getAttribute(attributeName));
    },
    
    getAttributeAsBoolean: function Framework_Util_DOMElementAttributeProvider$getAttributeAsBoolean(attributeName) {
        return Framework.Util.StringConverter.getAsBoolean(this._domElement.getAttribute(attributeName));
    },
    
    getAttributeAsEscapedString: function Framework_Util_DOMElementAttributeProvider$getAttributeAsEscapedString(attributeName) {
        return Framework.Util.StringConverter.getAsEscapedString(this._domElement.getAttribute(attributeName));
    },
    
    dispose: function Framework_Util_DOMElementAttributeProvider$dispose() {
        this._domElement = null;
    }
}


Type.createNamespace('Framework.Validation');

////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.ValidationResult

Framework.Validation.ValidationResult = function Framework_Validation_ValidationResult() {
}
Framework.Validation.ValidationResult.prototype = {
    success: false,
    exception: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.ValidationManager

Framework.Validation.ValidationManager = function Framework_Validation_ValidationManager(PageEnvironment) {
    this._environment = PageEnvironment;
    this.headerItemTemplate = '{0}<br />';
    this._validators = {};
}
Framework.Validation.ValidationManager.prototype = {
    _validators: null,
    _environment: null,
    headerElementId: null,
    headerItemTemplate: null,
    
    clearValidators: function Framework_Validation_ValidationManager$clearValidators() {
        Object.clearKeys(this._validators);
    },
    
    registerInputForValidation: function Framework_Validation_ValidationManager$registerInputForValidation(validator) {
        if (Object.keyExists(this._validators, validator.inputElementId.trim())) {
            var arrvalidators = this._validators[validator.inputElementId.trim()];
            this._validators[validator.inputElementId] = arrvalidators.concat(validator);
        }
        else {
            var arrvalidators = [ validator ];
            this._validators[validator.inputElementId.trim()] = arrvalidators;
        }
    },
    
    unregisterInputForValidation: function Framework_Validation_ValidationManager$unregisterInputForValidation(inputElementId) {
        if (Object.keyExists(this._validators, inputElementId.trim())) {
            delete this._validators[inputElementId.trim()];
        }
    },
    
    registerMandatoryValidator: function Framework_Validation_ValidationManager$registerMandatoryValidator(InputElementId, LabelElementId, ErrorElementId) {
        var _mandatoryValidator = new Framework.Validation.MandatoryValidator();
        _mandatoryValidator.inputElementId = InputElementId;
        _mandatoryValidator.errorElementId = ErrorElementId;
        _mandatoryValidator.labelElementId = LabelElementId;
        this.registerInputForValidation(_mandatoryValidator);
    },
    
    registerNumericValidator: function Framework_Validation_ValidationManager$registerNumericValidator(InputElementId, LabelElementId, ErrorElementId, Length) {
        var _numericValidator = new Framework.Validation.NumericValidator(Length);
        _numericValidator.inputElementId = InputElementId;
        _numericValidator.errorElementId = ErrorElementId;
        _numericValidator.labelElementId = LabelElementId;
        this.registerInputForValidation(_numericValidator);
    },
    
    registerNumericRangeValidator: function Framework_Validation_ValidationManager$registerNumericRangeValidator(InputElementId, LabelElementId, ErrorElementId, MinValue, MaxValue) {
        var _numericRngValidator = new Framework.Validation.NumericRangeValidator(MinValue, MaxValue);
        _numericRngValidator.inputElementId = InputElementId;
        _numericRngValidator.errorElementId = ErrorElementId;
        _numericRngValidator.labelElementId = LabelElementId;
        this.registerInputForValidation(_numericRngValidator);
    },
    
    registerDateValidator: function Framework_Validation_ValidationManager$registerDateValidator(InputElementId, LabelElementId, ErrorElementId, MinDate, MaxDate) {
        var _dateValidator = new Framework.Validation.DateValidator();
        _dateValidator.inputElementId = InputElementId;
        _dateValidator.errorElementId = ErrorElementId;
        _dateValidator.labelElementId = LabelElementId;
        _dateValidator.minDate = MinDate;
        _dateValidator.maxDate = MaxDate;
        this.registerInputForValidation(_dateValidator);
    },
    
    registerThreePartDateValidator: function Framework_Validation_ValidationManager$registerThreePartDateValidator(DayInputElementId, MonthInputElementId, YearInputelementId, LabelElementId, ErrorElementId, MinDate, MaxDate) {
        var _dateValidator = new Framework.Validation.ThreePartDateValidator();
        _dateValidator.dayInputId = DayInputElementId;
        _dateValidator.monthInputId = MonthInputElementId;
        _dateValidator.yearInputId = YearInputelementId;
        _dateValidator.errorElementId = ErrorElementId;
        _dateValidator.labelElementId = LabelElementId;
        _dateValidator.minDate = MinDate;
        _dateValidator.maxDate = MaxDate;
        this.registerInputForValidation(_dateValidator);
    },
    
    registerMinimumDateOfBirthValidator: function Framework_Validation_ValidationManager$registerMinimumDateOfBirthValidator(DayInputElementId, MonthInputElementId, YearInputelementId, LabelElementId, ErrorElementId, MinDate) {
        var _dateMinDOBValidator = new Framework.Validation.MinimumDateOfBirthValidator();
        _dateMinDOBValidator.dayInputId = DayInputElementId;
        _dateMinDOBValidator.monthInputId = MonthInputElementId;
        _dateMinDOBValidator.yearInputId = YearInputelementId;
        _dateMinDOBValidator.errorElementId = ErrorElementId;
        _dateMinDOBValidator.labelElementId = LabelElementId;
        _dateMinDOBValidator.minDate = MinDate;
        this.registerInputForValidation(_dateMinDOBValidator);
    },
    
    registerMinimumAgeValidator: function Framework_Validation_ValidationManager$registerMinimumAgeValidator(DayInputElementId, MonthInputElementId, YearInputelementId, LabelElementId, ErrorElementId, MinimumAge) {
        var _minAgeValidator = new Framework.Validation.ThreePartMinimumAgeValidator(MinimumAge);
        _minAgeValidator.dayInputId = DayInputElementId;
        _minAgeValidator.monthInputId = MonthInputElementId;
        _minAgeValidator.yearInputId = YearInputelementId;
        _minAgeValidator.errorElementId = ErrorElementId;
        _minAgeValidator.labelElementId = LabelElementId;
        this.registerInputForValidation(_minAgeValidator);
    },
    
    registerRegexValidator: function Framework_Validation_ValidationManager$registerRegexValidator(InputElementId, LabelElementId, ErrorElementId, Expression) {
        var _regexValidator = new Framework.Validation.RegexValidator(Expression);
        _regexValidator.inputElementId = InputElementId;
        _regexValidator.errorElementId = ErrorElementId;
        _regexValidator.labelElementId = LabelElementId;
        this.registerInputForValidation(_regexValidator);
    },
    
    registerEmailAddressValidator: function Framework_Validation_ValidationManager$registerEmailAddressValidator(InputElementId, LabelElementId, ErrorElementId) {
        var _emailVal = new Framework.Validation.EmailAddressValidator();
        _emailVal.inputElementId = InputElementId;
        _emailVal.errorElementId = ErrorElementId;
        _emailVal.labelElementId = LabelElementId;
        this.registerInputForValidation(_emailVal);
    },
    
    registerSameUsernamePasswordValidator: function Framework_Validation_ValidationManager$registerSameUsernamePasswordValidator(InputElementId, LabelElementId, ErrorElementId, InputUsernameID, InputPasswordID) {
        var _usernamePasswordValidator = new Framework.Validation.SameUsernamePasswordValidator();
        _usernamePasswordValidator.inputElementId = InputElementId;
        _usernamePasswordValidator.errorElementId = ErrorElementId;
        _usernamePasswordValidator.labelElementId = LabelElementId;
        _usernamePasswordValidator.inputUsernameID = InputUsernameID;
        _usernamePasswordValidator.inputPasswordID = InputPasswordID;
        this.registerInputForValidation(_usernamePasswordValidator);
    },
    
    registerValidateRUT: function Framework_Validation_ValidationManager$registerValidateRUT(InputElementId, LabelElementId, ErrorElementId) {
        var _validateRUT = new Framework.Validation.ValidateRUT();
        _validateRUT.inputElementId = InputElementId;
        _validateRUT.errorElementId = ErrorElementId;
        _validateRUT.labelElementId = LabelElementId;
        _validateRUT.inputUsernameId = InputElementId;
        this.registerInputForValidation(_validateRUT);
    },
    
    validateSingleInput: function Framework_Validation_ValidationManager$validateSingleInput(input) {
        var arrvalidators = this._validators[input.id.trim()];
        var $enum1 = arrvalidators.getEnumerator();
        while ($enum1.moveNext()) {
            var validator = $enum1.get_current();
            validator._environment = this._environment;
            if (!validator.validate()) {
                return false;
            }
        }
        return true;
    },
    
    validateAll: function Framework_Validation_ValidationManager$validateAll() {
        if (!String.isNullOrEmpty(this.headerElementId)) {
            this._environment.getDomElement(this.headerElementId).innerHTML = '';
        }
        var isValid = true;
        var $dict1 = this._validators;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var arrvalidators = entry.value;
            var $enum3 = arrvalidators.getEnumerator();
            while ($enum3.moveNext()) {
                var validator = $enum3.get_current();
                validator._environment = this._environment;
                if (!validator.validate()) {
                    if (!String.isNullOrEmpty(this.headerElementId)) {
                        this._environment.getDomElement(this.headerElementId).innerHTML = String.format(this.headerItemTemplate, validator.errorMessage);
                    }
                    isValid = false;
                    break;
                }
            }
        }
        if (!isValid) {
            window.scrollTo(0, 0);
        }
        return isValid;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.AbstractValidator

Framework.Validation.AbstractValidator = function Framework_Validation_AbstractValidator() {
    this._applyInputParentElementErrorClassOnError = true;
    this._inputParentElementErrorClass = 'ParentElementError';
    this._errorLabelClass = 'LabelError';
}
Framework.Validation.AbstractValidator.prototype = {
    _applyInputParentElementErrorClassOnError: false,
    _inputParentElementErrorClass: null,
    _errorLabelClass: null,
    _onSuccessCallBack: null,
    _onFailureCallBack: null,
    inputElementId: null,
    labelElementId: null,
    errorElementId: null,
    errorMessage: null,
    _environment: null,
    
    get_errorLabelClass: function Framework_Validation_AbstractValidator$get_errorLabelClass() {
        return this._errorLabelClass;
    },
    set_errorLabelClass: function Framework_Validation_AbstractValidator$set_errorLabelClass(value) {
        this._errorLabelClass = value;
        return value;
    },
    
    get_inputParentElementErrorClass: function Framework_Validation_AbstractValidator$get_inputParentElementErrorClass() {
        return this._inputParentElementErrorClass;
    },
    set_inputParentElementErrorClass: function Framework_Validation_AbstractValidator$set_inputParentElementErrorClass(value) {
        this._inputParentElementErrorClass = value;
        return value;
    },
    
    get_applyInputParentElementErrorClassOnError: function Framework_Validation_AbstractValidator$get_applyInputParentElementErrorClassOnError() {
        return this._applyInputParentElementErrorClassOnError;
    },
    set_applyInputParentElementErrorClassOnError: function Framework_Validation_AbstractValidator$set_applyInputParentElementErrorClassOnError(value) {
        this._applyInputParentElementErrorClassOnError = value;
        return value;
    },
    
    add_onSuccessEvent: function Framework_Validation_AbstractValidator$add_onSuccessEvent(value) {
        this._onSuccessCallBack = Delegate.combine(this._onSuccessCallBack, value);
    },
    remove_onSuccessEvent: function Framework_Validation_AbstractValidator$remove_onSuccessEvent(value) {
        this._onSuccessCallBack = Delegate.remove(this._onSuccessCallBack, value);
    },
    
    add_onFailureEvent: function Framework_Validation_AbstractValidator$add_onFailureEvent(value) {
        this._onFailureCallBack = Delegate.combine(this._onFailureCallBack, value);
    },
    remove_onFailureEvent: function Framework_Validation_AbstractValidator$remove_onFailureEvent(value) {
        this._onFailureCallBack = Delegate.remove(this._onFailureCallBack, value);
    },
    
    doesElementExist: function Framework_Validation_AbstractValidator$doesElementExist() {
        return (this._environment.getDomElement(this.inputElementId));
    },
    
    inputValue: function Framework_Validation_AbstractValidator$inputValue() {
        if (!this.doesElementExist()) {
            return null;
        }
        return (this._environment.getDomElement(this.inputElementId)).value;
    },
    
    validate: function Framework_Validation_AbstractValidator$validate() {
        return true;
    },
    
    getErrorText: function Framework_Validation_AbstractValidator$getErrorText() {
        if (!this._environment.getDomElement(this.errorElementId)) {
            return '';
        }
        if (!String.isNullOrEmpty(this.errorElementId)) {
            return this._environment.getDomElement(this.errorElementId).innerHTML;
        }
        return '';
    },
    
    createExceptionFromTextInErrorElement: function Framework_Validation_AbstractValidator$createExceptionFromTextInErrorElement() {
        return Framework.ExceptionUtil.createException(Framework.Validation.AbstractValidator.VALIDATIONEXCEPTIONTYPE, this.getErrorText());
    },
    
    onFailure: function Framework_Validation_AbstractValidator$onFailure(exception) {
        if (!String.isNullOrEmpty(this.errorElementId)) {
            if (this._environment.getDomElement(this.errorElementId)) {
                this._environment.safelySetCssClass(this.errorElementId, this._errorLabelClass);
            }
        }
        if (!String.isNullOrEmpty(this.labelElementId)) {
            if (this._environment.getDomElement(this.labelElementId)) {
                this._environment.safelySetCssClass(this.labelElementId, this._errorLabelClass);
            }
        }
        if (this._applyInputParentElementErrorClassOnError) {
            if (this._environment.getDomElement(this.inputElementId)) {
                this._environment.safelySetCssClassOnElement(this._environment.getDomElement(this.inputElementId).parentNode, this._inputParentElementErrorClass);
            }
        }
        this.errorMessage = exception.message;
        if (this._onFailureCallBack) {
            this._onFailureCallBack.invoke(exception);
        }
    },
    
    onSuccess: function Framework_Validation_AbstractValidator$onSuccess() {
        if (!String.isNullOrEmpty(this.errorElementId)) {
            if (this._environment.getDomElement(this.errorElementId)) {
                this._environment.safelyRemoveCssClass(this.errorElementId, this._errorLabelClass);
            }
        }
        if (!String.isNullOrEmpty(this.labelElementId)) {
            if (this._environment.getDomElement(this.labelElementId)) {
                this._environment.safelyRemoveCssClass(this.labelElementId, this._errorLabelClass);
            }
        }
        if (this._applyInputParentElementErrorClassOnError) {
            if (this._environment.getDomElement(this.inputElementId)) {
                this._environment.safelyRemoveCssClassOnElement(this._environment.getDomElement(this.inputElementId).parentNode, this._inputParentElementErrorClass);
            }
        }
        if (this._onSuccessCallBack) {
            this._onSuccessCallBack.invoke();
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.MandatoryValidator

Framework.Validation.MandatoryValidator = function Framework_Validation_MandatoryValidator() {
    Framework.Validation.MandatoryValidator.constructBase(this);
}
Framework.Validation.MandatoryValidator.prototype = {
    
    validate: function Framework_Validation_MandatoryValidator$validate() {
        if (this.doesElementExist()) {
            var val = '';
            if ((document.getElementById(this.inputElementId.trim())).type === 'checkbox') {
                if ((document.getElementById(this.inputElementId.trim())).checked) {
                    val = 'checked';
                }
                else {
                    val = String.Empty;
                }
            }
            else {
                val = (document.getElementById(this.inputElementId.trim())).value.trim();
            }
            if (!String.isNullOrEmpty(val)) {
                Framework.Validation.MandatoryValidator.callBase(this, 'onSuccess');
                return true;
            }
            else {
                var ex = new Error(this.getErrorText());
                Framework.Validation.MandatoryValidator.callBase(this, 'onFailure', [ ex ]);
                return false;
            }
        }
        else {
            Framework.Validation.MandatoryValidator.callBase(this, 'onSuccess');
            return true;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.DateValidator

Framework.Validation.DateValidator = function Framework_Validation_DateValidator() {
    Framework.Validation.DateValidator.constructBase(this);
}
Framework.Validation.DateValidator.prototype = {
    minDate: null,
    maxDate: null,
    
    validate: function Framework_Validation_DateValidator$validate() {
        var inputVal = this.inputValue();
        if (this.doesElementExist()) {
            var val = Date.get_today();
            try {
                val = Date.parse(inputVal);
            }
            catch ($e1) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            if (this.minDate && val.getTime() < this.minDate.getTime()) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            if (this.maxDate && val.getTime() > this.maxDate.getTime()) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
        }
        this.onSuccess();
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.ThreePartDateValidator

Framework.Validation.ThreePartDateValidator = function Framework_Validation_ThreePartDateValidator() {
    this.val = Date.get_now();
    Framework.Validation.ThreePartDateValidator.constructBase(this);
    this.inputElementId = Framework.Validation.AbstractValidator.UNASSIGNEDINPUTID;
}
Framework.Validation.ThreePartDateValidator.prototype = {
    dayInputId: null,
    monthInputId: null,
    yearInputId: null,
    day: null,
    month: null,
    year: null,
    minDate: null,
    maxDate: null,
    
    isValidDate: function Framework_Validation_ThreePartDateValidator$isValidDate(dayin, monthin, yearin) {
        if (isNaN(dayin)) {
            return false;
        }
        if (isNaN(monthin)) {
            return false;
        }
        if (isNaN(yearin)) {
            return false;
        }
        if (dayin <= 0 || yearin <= 0) {
            return false;
        }
        var validDate = true;
        var month30 = [ 4, 6, 9, 11 ];
        var month31 = [ 1, 3, 5, 7, 8, 10, 12 ];
        var oMonth;
        oMonth = monthin - 2;
        if (!oMonth & dayin > 28 + this._leapYear$1(yearin)) {
            validDate = false;
        }
        for (var i = 0; i < month30.length; i++) {
            oMonth = monthin - month30[i];
            if (!oMonth && dayin > 30) {
                validDate = false;
            }
        }
        for (var y = 0; y < month31.length; y++) {
            oMonth = monthin - month31[y];
            if (!oMonth && dayin > 31) {
                validDate = false;
            }
        }
        return validDate;
    },
    
    _leapYear$1: function Framework_Validation_ThreePartDateValidator$_leapYear$1(year) {
        var Result = 0;
        if (!(year % 4)) {
            if (!(year % 100)) {
                Result = (!(year % 400)) ? 1 : 0;
            }
            else {
                Result = 1;
            }
        }
        return Result;
    },
    
    validate: function Framework_Validation_ThreePartDateValidator$validate() {
        this.inputElementId = this.dayInputId;
        this.day = this.inputValue();
        this.inputElementId = this.monthInputId;
        this.month = this.inputValue();
        this.inputElementId = this.yearInputId;
        this.year = this.inputValue();
        if (!(String.isNullOrEmpty(this.day) || String.isNullOrEmpty(this.month) || String.isNullOrEmpty(this.year))) {
            if (!this.isValidDate(Number.parse(this.day), Number.parse(this.month), Number.parse(this.year))) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            this.val = new Date(Number.parse(this.year), Number.parse(this.month) - 1, Number.parse(this.day));
            if (!this.val) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            if (this.minDate && this.val.getTime() < this.minDate.getTime()) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            if (this.maxDate && this.val.getTime() > this.maxDate.getTime()) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
        }
        this.onSuccess();
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.MinimumDateOfBirthValidator

Framework.Validation.MinimumDateOfBirthValidator = function Framework_Validation_MinimumDateOfBirthValidator() {
    this.val = Date.get_now();
    Framework.Validation.MinimumDateOfBirthValidator.constructBase(this);
    this.inputElementId = Framework.Validation.AbstractValidator.UNASSIGNEDINPUTID;
}
Framework.Validation.MinimumDateOfBirthValidator.prototype = {
    dayInputId: null,
    monthInputId: null,
    yearInputId: null,
    day: null,
    month: null,
    year: null,
    minDate: null,
    
    validate: function Framework_Validation_MinimumDateOfBirthValidator$validate() {
        this.inputElementId = this.dayInputId;
        this.day = this.inputValue();
        this.inputElementId = this.monthInputId;
        this.month = this.inputValue();
        this.inputElementId = this.yearInputId;
        this.year = this.inputValue();
        if (!(String.isNullOrEmpty(this.day) || String.isNullOrEmpty(this.month) || String.isNullOrEmpty(this.year))) {
            this.val = new Date(Number.parse(this.year), Number.parse(this.month), Number.parse(this.day));
            if (!this.val) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
            if (this.minDate) {
                var heavyMinDOB = (this.minDate.getFullYear() * 1000) + (this.minDate.getMonth() * 100) + (this.minDate.getDate() * 10);
                var heavyDOB = (this.val.getFullYear() * 1000) + (this.val.getMonth() * 100) + (this.val.getDate() * 10);
                var isValidDate = (heavyMinDOB > heavyDOB) ? false : true;
                if (!isValidDate) {
                    this.onFailure(this.createExceptionFromTextInErrorElement());
                    return false;
                }
            }
        }
        this.onSuccess();
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.ThreePartMinimumAgeValidator

Framework.Validation.ThreePartMinimumAgeValidator = function Framework_Validation_ThreePartMinimumAgeValidator(MinAge) {
    Framework.Validation.ThreePartMinimumAgeValidator.constructBase(this);
    this.minimumAge = MinAge;
}
Framework.Validation.ThreePartMinimumAgeValidator.prototype = {
    
    validate: function Framework_Validation_ThreePartMinimumAgeValidator$validate() {
        this.inputElementId = this.dayInputId;
        this.day = this.inputValue();
        this.inputElementId = this.monthInputId;
        this.month = this.inputValue();
        this.inputElementId = this.yearInputId;
        this.year = this.inputValue();
        if (!(String.isNullOrEmpty(this.day) || String.isNullOrEmpty(this.month) || String.isNullOrEmpty(this.year))) {
            if (this.isValidDate(Number.parse(this.day), Number.parse(this.month), Number.parse(this.year))) {
                this.val = new Date(Number.parse(this.year), Number.parse(this.month) - 1, Number.parse(this.day));
                var temp = Date.get_now();
                var limit = new Date(temp.getFullYear() - this.minimumAge, temp.getMonth(), temp.getDate());
                if (limit.getTime() < this.val.getTime()) {
                    this.onFailure(this.createExceptionFromTextInErrorElement());
                    return false;
                }
            }
        }
        this.onSuccess();
        return true;
    },
    
    minimumAge: 0
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.NumericValidator

Framework.Validation.NumericValidator = function Framework_Validation_NumericValidator(length) {
    Framework.Validation.NumericValidator.constructBase(this);
    this.maxLength = 0;
    if (length > 0) {
        this.maxLength = length;
    }
}
Framework.Validation.NumericValidator.prototype = {
    
    validate: function Framework_Validation_NumericValidator$validate() {
        var val = this.inputValue();
        if (this.doesElementExist()) {
            var work = '*';
            if (this.maxLength > 0) {
                work = '{1,' + this.maxLength.toString() + '}';
            }
            var regex = new RegExp('^\\d' + work + '$');
            if (!regex.test(val)) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
        }
        this.onSuccess();
        return true;
    },
    
    maxLength: 0
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.StandardPasswordValidator

Framework.Validation.StandardPasswordValidator = function Framework_Validation_StandardPasswordValidator(minLength, maxLength) {
    Framework.Validation.StandardPasswordValidator.constructBase(this, [ '' ]);
    this.minimumLength = (minLength > 0) ? minLength : 4;
    this.maximumLength = (maxLength > 0) ? maxLength : 30;
    this._passwordRegex$2 = String.format('^[a-zA-Z0-9_@\\\\.]\\w{{0},{1}}$', this.minimumLength - 1, this.maximumLength - 1);
}
Framework.Validation.StandardPasswordValidator.prototype = {
    
    validate: function Framework_Validation_StandardPasswordValidator$validate() {
        this.regexString = this._passwordRegex$2;
        return Framework.Validation.StandardPasswordValidator.callBase(this, 'validate');
    },
    
    minimumLength: 0,
    maximumLength: 0,
    _passwordRegex$2: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.StandardUsernameValidator

Framework.Validation.StandardUsernameValidator = function Framework_Validation_StandardUsernameValidator(minLength, maxLength) {
    Framework.Validation.StandardUsernameValidator.constructBase(this, [ minLength, maxLength ]);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.EmailAddressValidator

Framework.Validation.EmailAddressValidator = function Framework_Validation_EmailAddressValidator() {
    Framework.Validation.EmailAddressValidator.constructBase(this, [ '^[0-9a-zA-Z]([-.\\w]*[0-9a-zA-Z_+])*@([0-9a-zA-Z][-\\w]*[0-9a-zA-Z]\\.)+[a-zA-Z]{2,9}$' ]);
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.MatchedInputsValidator

Framework.Validation.MatchedInputsValidator = function Framework_Validation_MatchedInputsValidator(Input1Id, Input2Id, Input2Label1Id, ErrorElementId) {
    Framework.Validation.MatchedInputsValidator.constructBase(this);
    this.inputElementId = Input2Id;
    this.errorElementId = ErrorElementId;
    this.labelElementId = Input2Label1Id;
    this.inputElement1Id = Input1Id;
    this.inputElement2Id = Input2Id;
}
Framework.Validation.MatchedInputsValidator.prototype = {
    inputElement1Id: null,
    inputElement2Id: null,
    
    validate: function Framework_Validation_MatchedInputsValidator$validate() {
        this.inputElementId = this.inputElement1Id;
        if (!this.doesElementExist()) {
            this.onSuccess();
            return true;
        }
        var input1 = this.inputValue();
        this.inputElementId = this.inputElement2Id;
        if (!this.doesElementExist()) {
            this.onSuccess();
            return true;
        }
        var input2 = this.inputValue();
        if (input1 !== input2) {
            this.onFailure(this.createExceptionFromTextInErrorElement());
            return false;
        }
        else {
            this.onSuccess();
            return true;
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.NumericRangeValidator

Framework.Validation.NumericRangeValidator = function Framework_Validation_NumericRangeValidator(minvalue, maxvalue) {
    Framework.Validation.NumericRangeValidator.constructBase(this);
    this.minValue = minvalue;
    this.maxValue = maxvalue;
}
Framework.Validation.NumericRangeValidator.prototype = {
    minValue: 0,
    maxValue: 0,
    
    validate: function Framework_Validation_NumericRangeValidator$validate() {
        var success = false;
        var val = this.inputValue();
        if (this.doesElementExist()) {
            var regex = new RegExp('^\\d*$');
            if (regex.test(val)) {
                success = true;
            }
            if (success) {
                var intVal = Number.parse(val);
                if (this.minValue > 0 && intVal < this.minValue) {
                    success = false;
                }
                if (this.maxValue > 0 && intVal > this.maxValue) {
                    success = false;
                }
            }
        }
        else {
            success = true;
        }
        if (success) {
            this.onSuccess();
        }
        else {
            this.onFailure(this.createExceptionFromTextInErrorElement());
        }
        return success;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.RegexValidator

Framework.Validation.RegexValidator = function Framework_Validation_RegexValidator(regex) {
    Framework.Validation.RegexValidator.constructBase(this);
    this.regexString = regex;
}
Framework.Validation.RegexValidator.prototype = {
    
    validate: function Framework_Validation_RegexValidator$validate() {
        var inputVal = this.inputValue();
        if (this.doesElementExist()) {
            var regex = new RegExp(this.regexString);
            if (!regex.test(inputVal)) {
                this.onFailure(this.createExceptionFromTextInErrorElement());
                return false;
            }
        }
        this.onSuccess();
        return true;
    },
    
    regexString: null
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.CustomValidator

Framework.Validation.CustomValidator = function Framework_Validation_CustomValidator() {
    Framework.Validation.CustomValidator.constructBase(this);
}
Framework.Validation.CustomValidator.prototype = {
    customValidatorMethod: null,
    
    validate: function Framework_Validation_CustomValidator$validate() {
        if (this.customValidatorMethod) {
            var result = this.customValidatorMethod.invoke(this.inputValue());
            if (result.success) {
                this.onSuccess();
                return true;
            }
            else {
                this.onFailure(result.exception);
                return false;
            }
        }
        return false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.SameUsernamePasswordValidator

Framework.Validation.SameUsernamePasswordValidator = function Framework_Validation_SameUsernamePasswordValidator() {
    Framework.Validation.SameUsernamePasswordValidator.constructBase(this);
}
Framework.Validation.SameUsernamePasswordValidator.prototype = {
    inputUsernameID: null,
    inputPasswordID: null,
    
    validate: function Framework_Validation_SameUsernamePasswordValidator$validate() {
        this.inputElementId = this.inputUsernameID;
        var Username = this.inputValue();
        this.inputElementId = this.inputPasswordID;
        var Password = this.inputValue();
        if (Username === Password) {
            this.onFailure(this.createExceptionFromTextInErrorElement());
            return false;
        }
        this.onSuccess();
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Framework.Validation.ValidateRUT

Framework.Validation.ValidateRUT = function Framework_Validation_ValidateRUT() {
    Framework.Validation.ValidateRUT.constructBase(this);
}
Framework.Validation.ValidateRUT.prototype = {
    inputUsernameId: null,
    
    validate: function Framework_Validation_ValidateRUT$validate() {
        this.inputElementId = this.inputUsernameId;
        var RUT = this.inputValue();
        var Kcheck = RUT.charAt(RUT.length - 1);
        if (!(Kcheck === 'k' || Kcheck === 'K' || (new RegExp('^\\d*$')).test(Kcheck.toString()))) {
            this.onFailure(this.createExceptionFromTextInErrorElement());
            return false;
        }
        RUT = RUT.substring(0, RUT.length - 1);
        var s1 = RUT.replace((new RegExp('[^0-9A-Za-z]', 'g')), '');
        var s2 = s1.replace((new RegExp('[0-9]', 'gi')), '');
        if (RUT.replace((new RegExp('[^0-9A-Za-z]', 'g')), '').replace((new RegExp('[0-9]', 'gi')), '').length) {
            this.onFailure(this.createExceptionFromTextInErrorElement());
            return false;
        }
        RUT = RUT.replace((new RegExp('[^0-9]', 'gi')), '') + Kcheck.toString();
        if (RUT.length < 6 || RUT.length > 9) {
            this.onFailure(this.createExceptionFromTextInErrorElement());
            return false;
        }
        if (this._checkMOD11$1(RUT, true)) {
            this.onSuccess();
            return true;
        }
        this.onFailure(this.createExceptionFromTextInErrorElement());
        return false;
    },
    
    _checkMOD11$1: function Framework_Validation_ValidateRUT$_checkMOD11$1(inStr, acceptMod10) {
        var validNum = '0123456789';
        var i;
        var resStr = '';
        var inStrLen = inStr.length;
        if (inStrLen >= 6) {
            resStr = inStr.substring(0, inStrLen - 1);
        }
        else {
            resStr = inStr.charAt(0);
        }
        var dv = inStr.charAt(inStrLen - 1);
        if (String.isNullOrEmpty(resStr) || String.isNullOrEmpty(dv)) {
            return false;
        }
        var drv = '0';
        var sum = 0;
        var mul = 2;
        for (i = resStr.length - 1; i >= 0; i--) {
            if (validNum.indexOf(resStr.charAt(i)) < 0) {
                return false;
            }
            var tmp = resStr.charAt(i);
            sum = sum + tmp * mul;
            if (mul === 7) {
                mul = 2;
            }
            else {
                mul++;
            }
        }
        var dvi;
        var res = sum % 11;
        if (res === 1) {
            if (acceptMod10) {
                drv = 'k';
            }
            else {
                return false;
            }
        }
        else if (!res) {
            drv = '0';
        }
        else {
            dvi = 11 - res;
            drv = dvi.toString();
        }
        if (drv !== dv.toLowerCase()) {
            return false;
        }
        return true;
    }
}


Framework.AbstractComponent.createClass('Framework.AbstractComponent');
Framework.AbstractEnvironment.createClass('Framework.AbstractEnvironment', null, Framework.IEnvironment);
Framework.AbstractService.createClass('Framework.AbstractService');
Framework.ComponentInfo.createClass('Framework.ComponentInfo');
Framework.PagerCall.createClass('Framework.PagerCall');
Framework.MessageIndicators.createClass('Framework.MessageIndicators');
Framework.Pager.createClass('Framework.Pager');
Framework.PagerLastCall.createClass('Framework.PagerLastCall');
Framework.BubblingEvent.createClass('Framework.BubblingEvent');
Framework.AdminClassNames.createClass('Framework.AdminClassNames');
Framework.AdminUrls.createClass('Framework.AdminUrls');
Framework.AdminPageIds.createClass('Framework.AdminPageIds');
Framework.AdminUtil.createClass('Framework.AdminUtil');
Framework.AdminDragController.createClass('Framework.AdminDragController');
Framework.AdminController.createClass('Framework.AdminController');
Framework.AutoWiring.createClass('Framework.AutoWiring');
Framework.BrowserUtil.createClass('Framework.BrowserUtil');
Framework.ComponentConfiguration.createClass('Framework.ComponentConfiguration');
Framework.CommonComponentParameters.createClass('Framework.CommonComponentParameters');
Framework.CookieUtil.createClass('Framework.CookieUtil');
Framework.AjaxUpdater.createClass('Framework.AjaxUpdater');
Framework.AbstractMessagingService.createClass('Framework.AbstractMessagingService', Framework.AbstractService);
Framework.DynamicComponentConfiguration.createClass('Framework.DynamicComponentConfiguration');
Framework.CustomCultureInfo.createClass('Framework.CustomCultureInfo');
Framework.NavigationTypeGroup.createClass('Framework.NavigationTypeGroup');
Framework.StringHelper.createClass('Framework.StringHelper');
Framework.ListenerInvoker.createClass('Framework.ListenerInvoker');
Framework.Parameters.createClass('Framework.Parameters');
Framework.DragEventArgs.createClass('Framework.DragEventArgs');
Framework.DragObjectPosition.createClass('Framework.DragObjectPosition');
Framework.DragArgs.createClass('Framework.DragArgs');
Framework.Droppables.createClass('Framework.Droppables');
Framework.DraggableStartLocations.createClass('Framework.DraggableStartLocations');
Framework.DragableControl.createClass('Framework.DragableControl', Object);
Framework.Position.createClass('Framework.Position');
Framework.DragController.createClass('Framework.DragController');
Framework.Logger.createClass('Framework.Logger');
Framework.JSONFormat.createClass('Framework.JSONFormat');
Framework.JsonRpcTask.createClass('Framework.JsonRpcTask', null, Framework.IRpcTask);
Framework.ExceptionDetails.createClass('Framework.ExceptionDetails');
Framework.ExceptionTypes.createClass('Framework.ExceptionTypes');
Framework.ExceptionUtil.createClass('Framework.ExceptionUtil');
Framework.Log.createClass('Framework.Log');
Framework.RemoteException.createClass('Framework.RemoteException');
Framework.ServiceConfiguration.createClass('Framework.ServiceConfiguration');
Framework.FormUtil.createClass('Framework.FormUtil');
Framework.DictionaryUtil.createClass('Framework.DictionaryUtil');
Framework.ToolTipBehavior.createClass('Framework.ToolTipBehavior', ScriptFX.UI.Behavior);
Framework.TransformAndUpdateTask.createClass('Framework.TransformAndUpdateTask');
Framework.DOMParser.createClass('Framework.DOMParser', null, IDisposable);
Framework.Behavior.Binding.BehaviorBinder.createClass('Framework.Behavior.Binding.BehaviorBinder');
Framework.Behavior.Binding.AbstractBinding.createClass('Framework.Behavior.Binding.AbstractBinding');
Framework.Behavior.Binding.OnKeyDownBinding.createClass('Framework.Behavior.Binding.OnKeyDownBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnSubmitBinding.createClass('Framework.Behavior.Binding.OnSubmitBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnBlurBinding.createClass('Framework.Behavior.Binding.OnBlurBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnFocusBinding.createClass('Framework.Behavior.Binding.OnFocusBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnMouseOutBinding.createClass('Framework.Behavior.Binding.OnMouseOutBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnMouseOverBinding.createClass('Framework.Behavior.Binding.OnMouseOverBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnKeyUpBinding.createClass('Framework.Behavior.Binding.OnKeyUpBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnChangeBinding.createClass('Framework.Behavior.Binding.OnChangeBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnLoadBinding.createClass('Framework.Behavior.Binding.OnLoadBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.Binding.OnClickBinding.createClass('Framework.Behavior.Binding.OnClickBinding', Framework.Behavior.Binding.AbstractBinding);
Framework.Behavior.ElementBehavior.createClass('Framework.Behavior.ElementBehavior', ScriptFX.UI.Behavior);
Framework.Behavior.OnKeyDownBehavior.createClass('Framework.Behavior.OnKeyDownBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnSubmitBehavior.createClass('Framework.Behavior.OnSubmitBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnBlurBehavior.createClass('Framework.Behavior.OnBlurBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnFocusBehavior.createClass('Framework.Behavior.OnFocusBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnMouseOutBehavior.createClass('Framework.Behavior.OnMouseOutBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnMouseOverBehavior.createClass('Framework.Behavior.OnMouseOverBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnKeyUpBehavior.createClass('Framework.Behavior.OnKeyUpBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnChangeBehavior.createClass('Framework.Behavior.OnChangeBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.OnLoadBehavior.createClass('Framework.Behavior.OnLoadBehavior');
Framework.Behavior.OnClickBehavior.createClass('Framework.Behavior.OnClickBehavior', Framework.Behavior.ElementBehavior);
Framework.Behavior.UrlRewrittingInfoObject.createClass('Framework.Behavior.UrlRewrittingInfoObject');
Framework.Behavior.EventArgs.BehaviorEventArgs.createClass('Framework.Behavior.EventArgs.BehaviorEventArgs');
Framework.Behavior.EventArgs.OnKeyDownEventArgs.createClass('Framework.Behavior.EventArgs.OnKeyDownEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnSubmitEventArgs.createClass('Framework.Behavior.EventArgs.OnSubmitEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnBlurEventArgs.createClass('Framework.Behavior.EventArgs.OnBlurEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnFocusEventArgs.createClass('Framework.Behavior.EventArgs.OnFocusEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnMouseOutEventArgs.createClass('Framework.Behavior.EventArgs.OnMouseOutEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnMouseOverEventArgs.createClass('Framework.Behavior.EventArgs.OnMouseOverEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnKeyUpEventArgs.createClass('Framework.Behavior.EventArgs.OnKeyUpEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.Parameters.createClass('Framework.Behavior.EventArgs.Parameters');
Framework.Behavior.EventArgs.OnLoadEventArgs.createClass('Framework.Behavior.EventArgs.OnLoadEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnChangeEventArgs.createClass('Framework.Behavior.EventArgs.OnChangeEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Behavior.EventArgs.OnClickEventArgs.createClass('Framework.Behavior.EventArgs.OnClickEventArgs', Framework.Behavior.EventArgs.BehaviorEventArgs);
Framework.Component.AbstractComponent.createClass('Framework.Component.AbstractComponent', null, Framework.Component.IDynamicComponent);
Framework.Component.ComponentFactory.createClass('Framework.Component.ComponentFactory');
Framework.Component.AbstractXsltBasedComponent.createClass('Framework.Component.AbstractXsltBasedComponent', Framework.Component.AbstractComponent);
Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.ChildrenUpdateCompleteEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.ChildUpdateCompleteEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.XmlContentReceivedEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.RenderCompleteEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.PreRenderEventArgs');
Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs.createClass('Framework.Component.LifeCycleManagement.EventArgs.PreTransformationEventArgs');
Framework.Component.LifeCycleManagement.ComponentLifeCycleManager.createClass('Framework.Component.LifeCycleManagement.ComponentLifeCycleManager');
Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager.createClass('Framework.Component.LifeCycleManagement.XsltBasedComponentLifeCycleManager', Framework.Component.LifeCycleManagement.ComponentLifeCycleManager);
Framework.Component.Updating.XsltBasedUpdateContextObject.createClass('Framework.Component.Updating.XsltBasedUpdateContextObject');
Framework.Component.Updating.ComponentUpdateScheduler.createClass('Framework.Component.Updating.ComponentUpdateScheduler');
Framework.Component.Updating.UpdateXsltBasedComponentTask.createClass('Framework.Component.Updating.UpdateXsltBasedComponentTask');
Framework.Component.Updating.HtmlUpdater.createClass('Framework.Component.Updating.HtmlUpdater');
Framework.SDC.SDCManager.createClass('Framework.SDC.SDCManager');
Framework.SDC.SDCStatistic.createClass('Framework.SDC.SDCStatistic');
Framework.SDC.SDCStatisticType.createClass('Framework.SDC.SDCStatisticType');
Framework.SDC.SDCExceptionType.createClass('Framework.SDC.SDCExceptionType');
Framework.SDC.SDCConfig.createClass('Framework.SDC.SDCConfig');
Framework.Util.TypeInfoProvider.createClass('Framework.Util.TypeInfoProvider');
Framework.Util.StringConverter.createClass('Framework.Util.StringConverter');
Framework.Util.DOMElementAttributeProvider.createClass('Framework.Util.DOMElementAttributeProvider', null, IDisposable);
Framework.Validation.ValidationResult.createClass('Framework.Validation.ValidationResult');
Framework.Validation.ValidationManager.createClass('Framework.Validation.ValidationManager');
Framework.Validation.AbstractValidator.createClass('Framework.Validation.AbstractValidator');
Framework.Validation.MandatoryValidator.createClass('Framework.Validation.MandatoryValidator', Framework.Validation.AbstractValidator);
Framework.Validation.DateValidator.createClass('Framework.Validation.DateValidator', Framework.Validation.AbstractValidator);
Framework.Validation.ThreePartDateValidator.createClass('Framework.Validation.ThreePartDateValidator', Framework.Validation.AbstractValidator);
Framework.Validation.MinimumDateOfBirthValidator.createClass('Framework.Validation.MinimumDateOfBirthValidator', Framework.Validation.AbstractValidator);
Framework.Validation.ThreePartMinimumAgeValidator.createClass('Framework.Validation.ThreePartMinimumAgeValidator', Framework.Validation.ThreePartDateValidator);
Framework.Validation.NumericValidator.createClass('Framework.Validation.NumericValidator', Framework.Validation.AbstractValidator);
Framework.Validation.RegexValidator.createClass('Framework.Validation.RegexValidator', Framework.Validation.AbstractValidator);
Framework.Validation.StandardPasswordValidator.createClass('Framework.Validation.StandardPasswordValidator', Framework.Validation.RegexValidator);
Framework.Validation.StandardUsernameValidator.createClass('Framework.Validation.StandardUsernameValidator', Framework.Validation.StandardPasswordValidator);
Framework.Validation.EmailAddressValidator.createClass('Framework.Validation.EmailAddressValidator', Framework.Validation.RegexValidator);
Framework.Validation.MatchedInputsValidator.createClass('Framework.Validation.MatchedInputsValidator', Framework.Validation.AbstractValidator);
Framework.Validation.NumericRangeValidator.createClass('Framework.Validation.NumericRangeValidator', Framework.Validation.AbstractValidator);
Framework.Validation.CustomValidator.createClass('Framework.Validation.CustomValidator', Framework.Validation.AbstractValidator);
Framework.Validation.SameUsernamePasswordValidator.createClass('Framework.Validation.SameUsernamePasswordValidator', Framework.Validation.AbstractValidator);
Framework.Validation.ValidateRUT.createClass('Framework.Validation.ValidateRUT', Framework.Validation.AbstractValidator);
Framework.AbstractComponent.noMessages = [];
Framework.AbstractEnvironment._log = Framework.Logger.getLog('AbstractEnvironment');
Framework.AbstractEnvironment._jsonpRequestTimeout = 60000;
Framework.AbstractEnvironment._enableMultiplexing = true;
Framework.AbstractEnvironment._debugMode = false;
Framework.AbstractEnvironment._singeltonAbstractEnvironment = null;
Framework.MessageIndicators.trueVal = 'True';
Framework.Pager.defaultCallBack = null;
Framework.PagerLastCall._callsByContainerId = {};
Framework.AutoWiring._ssrUserCookieName = 'IsSSRUser';
Framework.AutoWiring._log = Framework.Logger.getLog('AutoWiring');
Framework.CommonComponentParameters._log = Framework.Logger.getLog('CommonComponentParameters');
Framework.AjaxUpdater._scriptregex = '<script [^\\>]*>([^<]+)</script\\>';
Framework.AbstractMessagingService._log$1 = Framework.Logger.getLog('AbstractMessagingService');
Framework.CustomCultureInfo._customCultures = {};
Framework.CustomCultureInfo._regionalDefaultCulture = {};
Framework.ListenerInvoker._log = Framework.Logger.getLog('ListenerInvoker');
Framework.Parameters.transformAndUpdateSchedulerPeriod = 2000;
Framework.Droppables.drops = [];
Framework.Droppables.offsetLocation = ScriptFX.UI.$create_Location(0, 0);
Framework.DraggableStartLocations._dictionary = {};
Framework.Logger._isLoggingEnabled = false;
Framework.Logger._maximumLogSize = -1;
Framework.JSONFormat.dateFormat = 'd-M-yyyy H-m-s';
Framework.ExceptionTypes.remoteException = 'RemoteException';
Framework.ExceptionTypes.runtimeException = 'RuntimeException';
Framework.ExceptionUtil._log = Framework.Logger.getLog('ExceptionUtil');
Framework.ExceptionUtil._separator = '|';
Framework.Log._domElementName = 'debug';
Framework.TransformAndUpdateTask._log = Framework.Logger.getLog('TransformAndUpdateTask');
Framework.TransformAndUpdateTask._requestCounter = 1;
Framework.TransformAndUpdateTask._xmlCallBacks = {};
Framework.TransformAndUpdateTask._contentRequests = {};
Framework.TransformAndUpdateTask._domElementCounterMap = {};
Framework.TransformAndUpdateTask._cachedXsltXmlDocument = {};
Framework.Behavior.Binding.BehaviorBinder.behavioR_ID_ATTRIBUTE = 'behavior.ID';
Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_ID_ATTRIBUTE = 'behavior.autobind';
Framework.Behavior.Binding.BehaviorBinder.behavioR_EVENT_HANDLER_SUFFIX = 'EventHandler';
Framework.Behavior.ElementBehavior.behavioR_ID_ATTRIBUTE = 'behavior.ID';
Framework.Component.AbstractComponent.noMessages = [];
Framework.Component.ComponentFactory._log = Framework.Logger.getLog('ComponentFactory');
Framework.Component.ComponentFactory._dynamicComponentCounter = 0;
Framework.Component.Updating.ComponentUpdateScheduler._log = Framework.Logger.getLog('ServerUpdateScheduler');
Framework.Component.Updating.UpdateXsltBasedComponentTask._log = Framework.Logger.getLog('TransformAndUpdateTask');
Framework.Component.Updating.UpdateXsltBasedComponentTask._requestCounter = 1;
Framework.Component.Updating.UpdateXsltBasedComponentTask._xmlCallBacks = {};
Framework.Component.Updating.UpdateXsltBasedComponentTask._contentRequests = {};
Framework.Component.Updating.UpdateXsltBasedComponentTask._domElementCounterMap = {};
Framework.Component.Updating.UpdateXsltBasedComponentTask._cachedXsltXmlDocument = {};
Framework.Component.Updating.HtmlUpdater._log = Framework.Logger.getLog('DirectUpdater');
Framework.SDC.SDCManager._singletonSDCManager = null;
Framework.SDC.SDCManager.notLoggedInternalToken = '';
Framework.SDC.SDCManager._serviceName = 'StatisticsDataCollectionService';
Framework.SDC.SDCManager._minimumBatchSize = 15;
Framework.SDC.SDCManager._maximumBatchSize = 30;
Framework.SDC.SDCManager._timeoutInterval = 15 * 1000;
Framework.SDC.SDCManager._maxFailedBatchSendAttempts = 5;
Framework.SDC.SDCManager._priorityKeyPrefix = '1';
Framework.SDC.SDCStatisticType.render = 1;
Framework.SDC.SDCStatisticType.RPC = 2;
Framework.SDC.SDCStatisticType.sdcStatisticTypes = [ Framework.SDC.SDCStatisticType.render, Framework.SDC.SDCStatisticType.RPC ];
Framework.SDC.SDCExceptionType.noException = 0;
Framework.SDC.SDCExceptionType.callBrokerSystemException = 1;
Framework.SDC.SDCExceptionType.operationalException = 2;
Framework.SDC.SDCExceptionType.infrastructuralException = 3;
Framework.SDC.SDCExceptionType.callbrokerRPCException = 4;
Framework.Validation.AbstractValidator.VALIDATIONEXCEPTIONTYPE = 'System.Warp.ValidationException';
Framework.Validation.AbstractValidator.UNASSIGNEDINPUTID = '_unassigned';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------

Type.createNamespace('NavigationService');

////////////////////////////////////////////////////////////////////////////////
// NavigationService.IPageFilterChangedListener

NavigationService.IPageFilterChangedListener = function() { };
NavigationService.IPageFilterChangedListener.prototype = {
    onPageFilterChanged : null
}
NavigationService.IPageFilterChangedListener.createInterface('NavigationService.IPageFilterChangedListener');


////////////////////////////////////////////////////////////////////////////////
// NavigationService.GoToBehavior

NavigationService.GoToBehavior = function NavigationService_GoToBehavior(domElement, id, navigationService) {
    NavigationService.GoToBehavior.constructBase(this, [ domElement, id ]);
    this.get_domEvents().attach('onclick', Delegate.create(this, function() {
        var srcElement = window.event.srcElement;
        var pageArea = srcElement.getAttribute('pagearea');
        var pageFilter = srcElement.getAttribute('pagefilter');
        if (!String.isNullOrEmpty(pageArea)) {
            window.event.cancelBubble = true;
            window.event.returnValue = false;
            navigationService.goTo(pageArea, (String.isNullOrEmpty(pageFilter)) ? {} : eval('(' + pageFilter + ')'));
        }
        else if (!String.isNullOrEmpty(pageFilter)) {
            window.event.cancelBubble = true;
            window.event.returnValue = false;
            navigationService.setPageFilter(eval(pageFilter));
        }
    }));
}


////////////////////////////////////////////////////////////////////////////////
// NavigationService.NavigationService

NavigationService.NavigationService = function NavigationService_NavigationService() {
    this._pageFilter$1 = {};
    this._navigationStack$1 = [];
    this._httpsAreas$1 = {};
    this._httpsActions$1 = {};
    this._pageFilterChangedListeners$1 = [];
    this._topicalizedPageFilterChangedListeners$1 = {};
    NavigationService.NavigationService.constructBase(this);
    NavigationService.NavigationService._log$1.debug('ctor');
}
NavigationService.NavigationService.prototype = {
    _pageArea$1: null,
    _initialLoad$1: true,
    
    registerPageFilterChangedListener: function NavigationService_NavigationService$registerPageFilterChangedListener(pageFilterChangedListener) {
        NavigationService.NavigationService._log$1.debug('RegisterPageFilterChangedListener');
        if (!this._pageFilterChangedListeners$1.contains(pageFilterChangedListener)) {
            this._pageFilterChangedListeners$1.add(pageFilterChangedListener);
        }
    },
    
    unregisterPageFilterChangedListener: function NavigationService_NavigationService$unregisterPageFilterChangedListener(pageFilterChangedListener) {
        NavigationService.NavigationService._log$1.debug('UnregisterPageFilterChangedListener');
        this._pageFilterChangedListeners$1.remove(pageFilterChangedListener);
    },
    
    registerTopicalizedPageFilterChangedListener: function NavigationService_NavigationService$registerTopicalizedPageFilterChangedListener(pageFilterChangedListener, topic) {
        NavigationService.NavigationService._log$1.debug(String.format('RegisterTopicalizedPageFilterChangedListener topic=[{0}]', topic));
        if (!Object.keyExists(this._topicalizedPageFilterChangedListeners$1, topic)) {
            this._topicalizedPageFilterChangedListeners$1[topic] = [];
        }
        if (!(this._topicalizedPageFilterChangedListeners$1[topic]).contains(pageFilterChangedListener)) {
            (this._topicalizedPageFilterChangedListeners$1[topic]).add(pageFilterChangedListener);
        }
    },
    
    unregisterFromAllTopicsPageFilterChangedListener: function NavigationService_NavigationService$unregisterFromAllTopicsPageFilterChangedListener(pageFilterChangedListener) {
        NavigationService.NavigationService._log$1.debug('UnregisterFromAllTopicsPageFilterChangedListener');
        var $dict1 = this._topicalizedPageFilterChangedListeners$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            (entry.value).remove(pageFilterChangedListener);
        }
    },
    
    _firePageFilterChangedEvent$1: function NavigationService_NavigationService$_firePageFilterChangedEvent$1(listeners) {
        NavigationService.NavigationService._log$1.debug('FirePageFilterChangedEvent');
        var pageFilterChangedListeners;
        pageFilterChangedListeners = listeners;
        var $enum1 = pageFilterChangedListeners.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onPageFilterChanged(this);
            }
            catch (ex) {
                NavigationService.NavigationService._log$1.error('FirePageFilterChangedEvent OnPageFilterChanged', ex);
            }
        }
    },
    
    init: function NavigationService_NavigationService$init(environment, parameters) {
        NavigationService.NavigationService._log$1.debug(String.format('Init environment=[{0}] parameters=[{1}]', environment.toString(), Framework.DictionaryUtil.dumpToString(parameters)));
        NavigationService.NavigationService.callBase(this, 'init', [ environment, parameters ]);
        var httpsAreas = (parameters['https-areas']).split(',');
        var httpsActions = (parameters['https-actions']).split(',');
        for (var i = 0; i < httpsAreas.length; i++) {
            this._httpsAreas$1[httpsAreas[i].toLowerCase()] = true;
        }
        for (var i = 0; i < httpsActions.length; i++) {
            this._httpsActions$1[httpsActions[i].toLowerCase()] = true;
        }
        this._pageArea$1 = environment.getPageArea();
        this._pageFilter$1 = environment.getInitialPageFilter();
        if (ScriptFX.Application.current.get_host().get_name() === ScriptFX.HostName.IE) {
            var iframe = window.document.createElement('IFRAME');
            iframe.style.display = 'none';
            iframe.id = '_historyFrame';
            iframe.src = '/common/Empty.htm';
            window.document.body.appendChild(iframe);
        }
        ScriptFX.Application.current.enableHistory();
        ScriptFX.Application.current.get_history().add_navigated(Delegate.create(this, this._history_Navigated$1));
        if (Object.keyExists(this._httpsAreas$1, this._pageArea$1.toLowerCase()) && this._environment.getProtocol().toLowerCase() === 'http') {
            this._environment.changeLocation(this._pageArea$1, this._environment.getInitialPageFilter(), true, 'https');
        }
        if (this.getAction() !== String.Empty) {
            if (Object.keyExists(this._httpsActions$1, this.getAction().toLowerCase()) && this._environment.getProtocol().toLowerCase() === 'http') {
                this._environment.changeLocation(this._pageArea$1, this._environment.getInitialPageFilter(), true, 'https');
            }
        }
    },
    
    _history_Navigated$1: function NavigationService_NavigationService$_history_Navigated$1(sender, e) {
        if (this._initialLoad$1) {
            this._initialLoad$1 = false;
            var hash = window.location.hash.remove(0, 1);
            if (!isNullOrUndefined(hash) && !String.isNullOrEmpty(hash)) {
                ScriptFX.Application.current.get_history().addEntry(hash);
            }
        }
        else {
            if (String.isNullOrEmpty(e.get_entryName())) {
                ScriptFX.Application.current.get_history().goBack();
            }
            else {
                var hashFragments = e.get_entryName().split('&');
                var pageFilter = {};
                var $enum1 = hashFragments.getEnumerator();
                while ($enum1.moveNext()) {
                    var hashFragment = $enum1.get_current();
                    pageFilter[hashFragment.split('=')[0]] = hashFragment.split('=')[1];
                }
                this.goTo(this.getPageArea(), pageFilter);
            }
        }
    },
    
    start: function NavigationService_NavigationService$start() {
        NavigationService.NavigationService._log$1.debug('Start');
    },
    
    getPageArea: function NavigationService_NavigationService$getPageArea() {
        return this._pageArea$1;
    },
    
    getPageFilter: function NavigationService_NavigationService$getPageFilter() {
        var result = {};
        var $dict1 = this._pageFilter$1;
        for (var $key2 in $dict1) {
            var de = { key: $key2, value: $dict1[$key2] };
            result[de.key] = de.value;
        }
        return result;
    },
    
    setPageFilter: function NavigationService_NavigationService$setPageFilter(pageFilter) {
        this.goTo(this._pageArea$1, pageFilter);
    },
    
    getAction: function NavigationService_NavigationService$getAction() {
        if (Object.keyExists(this._pageFilter$1, NavigationService.NavigationService.action)) {
            return this._pageFilter$1[NavigationService.NavigationService.action];
        }
        return String.Empty;
    },
    
    setAction: function NavigationService_NavigationService$setAction(action) {
        var pageFilter = {};
        var $dict1 = this._pageFilter$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (String.compare(entry.key, NavigationService.NavigationService.action, true)) {
                pageFilter[entry.key] = entry.value;
            }
        }
        if (!String.isNullOrEmpty(action)) {
            pageFilter[NavigationService.NavigationService.action] = action;
        }
        this.goTo(this._pageArea$1, pageFilter);
    },
    
    goTo: function NavigationService_NavigationService$goTo(pageArea, pageFilter) {
        NavigationService.NavigationService._log$1.debug(String.format('GoTo pageArea=[{0}] pageFilter=[{1}]', pageArea, Framework.DictionaryUtil.dumpToString(pageFilter)));
        var currentAction = String.Empty;
        if (Object.keyExists(pageFilter, NavigationService.NavigationService.action)) {
            currentAction = pageFilter[NavigationService.NavigationService.action];
        }
        var protocol = (Object.keyExists(this._httpsAreas$1, pageArea.toLowerCase())) ? 'https' : (Object.keyExists(this._httpsActions$1, currentAction)) ? 'https' : 'http';
        if (String.equals(this._pageArea$1, pageArea, true) && (String.isNullOrEmpty(protocol) || String.equals(protocol, this._environment.getProtocol(), true))) {
            var changedTopics = [];
            var $dict1 = this._pageFilter$1;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                if (!Object.keyExists(pageFilter, entry.key) || pageFilter[entry.key] !== entry.value) {
                    changedTopics.add(entry.key);
                }
            }
            var $dict3 = pageFilter;
            for (var $key4 in $dict3) {
                var entry = { key: $key4, value: $dict3[$key4] };
                if (!changedTopics.contains(entry.key) && (!Object.keyExists(this._pageFilter$1, entry.key) || this._pageFilter$1[entry.key] !== entry.value)) {
                    changedTopics.add(entry.key);
                }
            }
            var listeners = [];
            for (var i = 0; i < this._pageFilterChangedListeners$1.length; i++) {
                listeners.add(this._pageFilterChangedListeners$1[i]);
            }
            for (var i = 0; i < changedTopics.length; i++) {
                var topicListeners = [];
                if (Object.keyExists(this._topicalizedPageFilterChangedListeners$1, changedTopics[i])) {
                    topicListeners = this._topicalizedPageFilterChangedListeners$1[changedTopics[i]];
                }
                for (var j = 0; j < topicListeners.length; j++) {
                    if (!listeners.contains(topicListeners[j])) {
                        listeners.add(topicListeners[j]);
                    }
                }
            }
            if (changedTopics.length > 0) {
                this._pageFilter$1 = pageFilter;
                this._environment.setHash(pageFilter);
                this._firePageFilterChangedEvent$1(listeners);
            }
        }
        else {
            this._environment.changeLocation(pageArea, pageFilter, true, protocol);
        }
    },
    
    forwardTo: function NavigationService_NavigationService$forwardTo(pageArea, pageFilter) {
        NavigationService.NavigationService._log$1.debug(String.format('ForwardTo pageArea=[{0}] pageFilter=[{1}]', pageArea, Framework.DictionaryUtil.dumpToString(pageFilter)));
        this._navigationStack$1.add(new NavigationService.NavigationStackElement(this._pageArea$1, this._pageFilter$1));
        this.goTo(pageArea, pageFilter);
    },
    
    isEmpty: function NavigationService_NavigationService$isEmpty() {
        return !this._navigationStack$1.length;
    },
    
    goBack: function NavigationService_NavigationService$goBack() {
        NavigationService.NavigationService._log$1.debug('GoBack');
        var top = this._navigationStack$1.removeAt(this._navigationStack$1.length - 1);
        if (top) {
            this.goTo(top.pageArea, top.pageFilter);
        }
    },
    
    goBackAndReport: function NavigationService_NavigationService$goBackAndReport() {
        NavigationService.NavigationService._log$1.debug('GoBackAndReport');
        var top = this._navigationStack$1.removeAt(this._navigationStack$1.length - 1);
        if (top) {
            this.goTo(top.pageArea, top.pageFilter);
            return true;
        }
        return false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// NavigationService.NavigationStackElement

NavigationService.NavigationStackElement = function NavigationService_NavigationStackElement(pageArea, pageFilter) {
    this.pageArea = pageArea;
    this.pageFilter = pageFilter;
}
NavigationService.NavigationStackElement.prototype = {
    pageArea: null,
    pageFilter: null
}


NavigationService.GoToBehavior.createClass('NavigationService.GoToBehavior', ScriptFX.UI.Behavior);
NavigationService.NavigationService.createClass('NavigationService.NavigationService', Framework.AbstractService);
NavigationService.NavigationStackElement.createClass('NavigationService.NavigationStackElement');
NavigationService.NavigationService._log$1 = Framework.Logger.getLog('NavigationService');
NavigationService.NavigationService.action = 'action';
NavigationService.NavigationService.page = 'page';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('GamesHostService');

////////////////////////////////////////////////////////////////////////////////
// GamesHostService.GamesHostService

GamesHostService.GamesHostService = function GamesHostService_GamesHostService() {
    this._gamesSessionID$1 = String.Empty;
    GamesHostService.GamesHostService.constructBase(this);
    GamesHostService.GamesHostService._log$1.debug('Ctor');
}
GamesHostService.GamesHostService.prototype = {
    _sessionTimeoutPageArea$1: null,
    
    get_gamesSessionID: function GamesHostService_GamesHostService$get_gamesSessionID() {
        return this._gamesSessionID$1;
    },
    
    _handleSessionTimeout$1: function GamesHostService_GamesHostService$_handleSessionTimeout$1(exception) {
        if (Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') {
            this._environment.changeLocation(this._sessionTimeoutPageArea$1, {}, false, null);
        }
    },
    
    onPageWillChange: function GamesHostService_GamesHostService$onPageWillChange() {
        GamesHostService.GamesHostService._log$1.debug('OnPageWillChange');
        var state = this._environment.getStoredState(GamesHostService.GamesHostService._serviceName$1);
        if (!state) {
            state = {};
        }
        state['gamesSessionID'] = this._gamesSessionID$1;
        this._environment.storeState(GamesHostService.GamesHostService._serviceName$1, state);
    },
    
    init: function GamesHostService_GamesHostService$init(environment, parameters) {
        GamesHostService.GamesHostService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        GamesHostService.GamesHostService.callBase(this, 'init', [ environment, parameters ]);
        this._sessionTimeoutPageArea$1 = parameters['session-timeout-page-area'];
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(GamesHostService.GamesHostService._serviceName$1);
        if (state) {
            this._gamesSessionID$1 = state['gamesSessionID'];
        }
        GamesHostService.GamesHostService._log$1.debug(String.format('Retrieving gamesSessionID, gamesSessionID= [{0}]', this._gamesSessionID$1));
    },
    
    start: function GamesHostService_GamesHostService$start() {
        GamesHostService.GamesHostService._log$1.debug(String.format('Start IsLoggedInGames={0}', this.isLoggedIn()));
    },
    
    isLoggedIn: function GamesHostService_GamesHostService$isLoggedIn() {
        GamesHostService.GamesHostService._log$1.debug('IsLoggedIn');
        return this._gamesSessionID$1 !== String.Empty;
    },
    
    login: function GamesHostService_GamesHostService$login(successCallback, failureCallback) {
        GamesHostService.GamesHostService._log$1.debug(String.format('Login IDDCSession=[{0}]'));
        this._environment.invokeAsync(GamesHostService.GamesHostService._serviceName$1, 'Login', {}, Delegate.create(this, function(result) {
            this._gamesSessionID$1 = result;
            successCallback.invoke(result);
        }), failureCallback);
    },
    
    logout: function GamesHostService_GamesHostService$logout(successCallback, failureCallback) {
        GamesHostService.GamesHostService._log$1.debug('Logout');
        this._environment.invokeAsync(GamesHostService.GamesHostService._serviceName$1, 'Logout', {}, Delegate.create(this, function(result) {
            this._gamesSessionID$1 = String.Empty;
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            GamesHostService.GamesHostService._log$1.debug(String.format('Error while logging out errorMessage = [{0}]', Framework.ExceptionUtil.getExceptionDetails(exception).get_message()));
            this._gamesSessionID$1 = String.Empty;
            failureCallback.invoke(exception);
        }));
    },
    
    getConfigParameter: function GamesHostService_GamesHostService$getConfigParameter(configKey) {
    }
}


GamesHostService.GamesHostService.createClass('GamesHostService.GamesHostService', Framework.AbstractService, Framework.IPageWillChangeListener);
GamesHostService.GamesHostService._serviceName$1 = 'GamesHostService';
GamesHostService.GamesHostService._log$1 = Framework.Logger.getLog(GamesHostService.GamesHostService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('BusinessUnitService');

////////////////////////////////////////////////////////////////////////////////
// BusinessUnitService.BusinessUnitService

BusinessUnitService.BusinessUnitService = function BusinessUnitService_BusinessUnitService() {
    BusinessUnitService.BusinessUnitService.constructBase(this);
}
BusinessUnitService.BusinessUnitService.prototype = {
    _dateTimeOffset$1: 0,
    _businessUnit$1: null,
    
    start: function BusinessUnitService_BusinessUnitService$start() {
        BusinessUnitService.BusinessUnitService._log$1.debug('Start');
    },
    
    getDateTimeOffset: function BusinessUnitService_BusinessUnitService$getDateTimeOffset() {
        return this._dateTimeOffset$1;
    },
    
    getBusinessUnitId: function BusinessUnitService_BusinessUnitService$getBusinessUnitId() {
        return this._businessUnit$1;
    },
    
    getBusinessUnitIdAsync: function BusinessUnitService_BusinessUnitService$getBusinessUnitIdAsync(successCallback, failureCallback) {
        BusinessUnitService.BusinessUnitService._log$1.debug('GetBusinessUnitId');
        this._environment.invokeAsync(BusinessUnitService.BusinessUnitService._serviceName$1, 'GetBusinessUnitId', {}, Delegate.create(this, function(result) {
            this._businessUnit$1 = result;
            if (successCallback) {
                successCallback.invoke(result);
            }
        }), Delegate.create(this, function(exception) {
            BusinessUnitService.BusinessUnitService._log$1.debug('GetBusinessUnitId exception ' + exception.message);
            failureCallback.invoke(exception);
        }));
    },
    
    getCurrentTime: function BusinessUnitService_BusinessUnitService$getCurrentTime(successCallback, failureCallback) {
        BusinessUnitService.BusinessUnitService._log$1.debug('GetCurrentTime');
        this._environment.invokeAsync(BusinessUnitService.BusinessUnitService._serviceName$1, 'GetCurrentTime', {}, Delegate.create(this, function(result) {
            var currentDateTime = Framework.JSONFormat.parseDateTime(result);
            this._dateTimeOffset$1 = currentDateTime.getTime() - Date.get_now().getTime();
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            BusinessUnitService.BusinessUnitService._log$1.debug('GetCurrentTime exception ' + exception.message);
            failureCallback.invoke(exception);
        }));
    },
    
    getDepositLimitConfiguration: function BusinessUnitService_BusinessUnitService$getDepositLimitConfiguration(successCallback, failureCallback) {
        BusinessUnitService.BusinessUnitService._log$1.debug('GetDepositLimitConfiguration');
        this._environment.invokeAsync(BusinessUnitService.BusinessUnitService._serviceName$1, 'GetDepositLimitConfiguration', {}, successCallback, Delegate.create(this, function(exception) {
            BusinessUnitService.BusinessUnitService._log$1.debug('GetDepositLimitConfiguration exception ' + exception.message);
            failureCallback.invoke(exception);
        }));
    },
    
    getCurrencyCode: function BusinessUnitService_BusinessUnitService$getCurrencyCode(countryCode) {
        BusinessUnitService.BusinessUnitService._log$1.debug(String.format('GetCurrencyCode countryCode[{0}]', countryCode));
        return (new BusinessUnitService.CountryCurrencyMap()).getCurrencyCode(countryCode);
    }
}


////////////////////////////////////////////////////////////////////////////////
// BusinessUnitService.CountryCurrencyMap

BusinessUnitService.CountryCurrencyMap = function BusinessUnitService_CountryCurrencyMap() {
    this._ccmap = [];
    this._ccmap.add('GB:GBP');
    this._ccmap.add('US:USD');
    this._ccmap.add('UM:USD');
    this._ccmap.add('AS:USD');
    this._ccmap.add('IO:USD');
    this._ccmap.add('TP:USD');
    this._ccmap.add('EC:USD');
    this._ccmap.add('SV:USD');
    this._ccmap.add('GU:USD');
    this._ccmap.add('HT:USD');
    this._ccmap.add('MH:USD');
    this._ccmap.add('FM:USD');
    this._ccmap.add('MP:USD');
    this._ccmap.add('PW:USD');
    this._ccmap.add('PA:USD');
    this._ccmap.add('PR:USD');
    this._ccmap.add('TC:USD');
    this._ccmap.add('VG:USD');
    this._ccmap.add('VI:USD');
    this._ccmap.add('CA:CAD');
    this._ccmap.add('AU:AUD');
    this._ccmap.add('CX:AUD');
    this._ccmap.add('CC:AUD');
    this._ccmap.add('HM:AUD');
    this._ccmap.add('KI:AUD');
    this._ccmap.add('NR:AUD');
    this._ccmap.add('NF:AUD');
    this._ccmap.add('TV:AUD');
    this._ccmap.add('DK:DKK');
    this._ccmap.add('FO:DKK');
    this._ccmap.add('GL:DKK');
    this._ccmap.add('AT:EUR');
    this._ccmap.add('AD:EUR');
    this._ccmap.add('BE:EUR');
    this._ccmap.add('FI:EUR');
    this._ccmap.add('FR:EUR');
    this._ccmap.add('GF:EUR');
    this._ccmap.add('TF:EUR');
    this._ccmap.add('DE:EUR');
    this._ccmap.add('GR:EUR');
    this._ccmap.add('GP:EUR');
    this._ccmap.add('VA:EUR');
    this._ccmap.add('IE:EUR');
    this._ccmap.add('IT:EUR');
    this._ccmap.add('LU:EUR');
    this._ccmap.add('MQ:EUR');
    this._ccmap.add('YT:EUR');
    this._ccmap.add('MC:EUR');
    this._ccmap.add('NL:EUR');
    this._ccmap.add('PT:EUR');
    this._ccmap.add('RE:EUR');
    this._ccmap.add('PM:EUR');
    this._ccmap.add('SM:EUR');
    this._ccmap.add('ES:EUR');
    this._ccmap.add('HK:HKD');
    this._ccmap.add('JP:JPY');
    this._ccmap.add('BV:NOK');
    this._ccmap.add('NO:NOK');
    this._ccmap.add('SJ:NOK');
    this._ccmap.add('SG:SGD');
    this._ccmap.add('ZA:ZAR');
    this._ccmap.add('SE:SEK');
    this._ccmap.add('CH:CHF');
    this._ccmap.add('LI:CHF');
    this._ccmap.add('TH:THB');
}
BusinessUnitService.CountryCurrencyMap.prototype = {
    _ccmap: null,
    
    getCurrencyCode: function BusinessUnitService_CountryCurrencyMap$getCurrencyCode(countryCode) {
        var currencyCode = null;
        for (var c = 0; c < this._ccmap.length; c++) {
            var mapEntry = this._ccmap[c].toString();
            var ccPair = mapEntry.split(':');
            var pairCountryCode = ccPair[0];
            var pairCurrencyCode = ccPair[1];
            if (Framework.StringHelper.equals(pairCountryCode, countryCode, true)) {
                currencyCode = pairCurrencyCode;
                break;
            }
        }
        return currencyCode;
    }
}


////////////////////////////////////////////////////////////////////////////////
// BusinessUnitService.DepositLimitConfiguration

BusinessUnitService.DepositLimitConfiguration = function BusinessUnitService_DepositLimitConfiguration() {
}
BusinessUnitService.DepositLimitConfiguration.prototype = {
    IDMMPeriodUnit: null,
    PendingPeriodDays: 0
}


BusinessUnitService.BusinessUnitService.createClass('BusinessUnitService.BusinessUnitService', Framework.AbstractService);
BusinessUnitService.CountryCurrencyMap.createClass('BusinessUnitService.CountryCurrencyMap');
BusinessUnitService.DepositLimitConfiguration.createClass('BusinessUnitService.DepositLimitConfiguration');
BusinessUnitService.BusinessUnitService._serviceName$1 = 'BusinessUnitService';
BusinessUnitService.BusinessUnitService._log$1 = Framework.Logger.getLog(BusinessUnitService.BusinessUnitService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('UserService');

////////////////////////////////////////////////////////////////////////////////
// UserService.IPreRegisterCustomerListener

UserService.IPreRegisterCustomerListener = function() { };
UserService.IPreRegisterCustomerListener.prototype = {
    onPreRegisterCustomer : null
}
UserService.IPreRegisterCustomerListener.createInterface('UserService.IPreRegisterCustomerListener');


////////////////////////////////////////////////////////////////////////////////
// UserService.IUserIsRegisteredListener

UserService.IUserIsRegisteredListener = function() { };
UserService.IUserIsRegisteredListener.prototype = {
    onUserRegistered : null
}
UserService.IUserIsRegisteredListener.createInterface('UserService.IUserIsRegisteredListener');


////////////////////////////////////////////////////////////////////////////////
// UserService.IUserChangedListener

UserService.IUserChangedListener = function() { };
UserService.IUserChangedListener.prototype = {
    onUserChanged : null
}
UserService.IUserChangedListener.createInterface('UserService.IUserChangedListener');


////////////////////////////////////////////////////////////////////////////////
// UserService.IUserPersonalDetailsChangedListener

UserService.IUserPersonalDetailsChangedListener = function() { };
UserService.IUserPersonalDetailsChangedListener.prototype = {
    onUserPersonalDetailsChanged : null
}
UserService.IUserPersonalDetailsChangedListener.createInterface('UserService.IUserPersonalDetailsChangedListener');


////////////////////////////////////////////////////////////////////////////////
// UserService.PlayerProtectionDetails

UserService.PlayerProtectionDetails = function UserService_PlayerProtectionDetails() {
}
UserService.PlayerProtectionDetails.prototype = {
    ExpiryDate: null,
    IDFOPlayerProtectionArea: null,
    PlayerProtectionAreaName: null
}


////////////////////////////////////////////////////////////////////////////////
// UserService.UpgradeCallCentreCustomerDetails

UserService.UpgradeCallCentreCustomerDetails = function UserService_UpgradeCallCentreCustomerDetails(formDetails) {
    if (Object.keyExists(formDetails, 'AccountNumber')) {
        this.AccountNumber = formDetails['AccountNumber'];
    }
    if (Object.keyExists(formDetails, 'Pin')) {
        this.Pin = formDetails['Pin'];
    }
    if (Object.keyExists(formDetails, 'PrimaryEmail')) {
        this.PrimaryEmail = formDetails['PrimaryEmail'];
    }
    if (Object.keyExists(formDetails, 'HomePhone')) {
        this.HomePhone = formDetails['HomePhone'];
    }
    if (Object.keyExists(formDetails, 'IsNoCorrespondence')) {
        this.IsNoCorrespondence = formDetails['IsNoCorrespondence'];
    }
    if (Object.keyExists(formDetails, 'DateOfBirth')) {
        this.DateOfBirth = formDetails['DateOfBirth'];
    }
    if (Object.keyExists(formDetails, 'UserName')) {
        this.UserName = formDetails['UserName'];
    }
    if (Object.keyExists(formDetails, 'Password')) {
        this.Password = formDetails['Password'];
    }
    if (Object.keyExists(formDetails, 'OddsType')) {
        this.OddsType = formDetails['OddsType'];
    }
    if (Object.keyExists(formDetails, 'IDDCSecretQuestion')) {
        this.IDDCSecretQuestion = formDetails['IDDCSecretQuestion'];
    }
    if (Object.keyExists(formDetails, 'SecretQuestion')) {
        this.SecretQuestion = formDetails['SecretQuestion'];
    }
    if (Object.keyExists(formDetails, 'SecretAnswer')) {
        this.SecretAnswer = formDetails['SecretAnswer'];
    }
}
UserService.UpgradeCallCentreCustomerDetails.prototype = {
    AccountNumber: null,
    Pin: null,
    PrimaryEmail: null,
    HomePhone: null,
    IsNoCorrespondence: false,
    DateOfBirth: null,
    UserName: null,
    Password: null,
    OddsType: null,
    IDDCSecretQuestion: null,
    SecretQuestion: null,
    SecretAnswer: null
}


////////////////////////////////////////////////////////////////////////////////
// UserService.UserService

UserService.UserService = function UserService_UserService() {
    this._userChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._userPersonalDetailsChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._userRegisteredListeners$1 = new Framework.ListenerInvoker(true);
    this._preRegisterCustomerListeners$1 = new Framework.ListenerInvoker(false);
    UserService.UserService.constructBase(this);
    UserService.UserService._log$1.debug('Ctor');
}
UserService.UserService.prototype = {
    _isLoginSecure$1: true,
    _fimsIDCookieName$1: '',
    _allowUpdateTitle$1: false,
    _allowUpdateDOB$1: false,
    _userLoggedOut$1: false,
    
    get_fimsIDCookieName: function UserService_UserService$get_fimsIDCookieName() {
        return this._fimsIDCookieName$1;
    },
    set_fimsIDCookieName: function UserService_UserService$set_fimsIDCookieName(value) {
        this._fimsIDCookieName$1 = value;
        return value;
    },
    
    get_userLoggedOut: function UserService_UserService$get_userLoggedOut() {
        return this._userLoggedOut$1;
    },
    set_userLoggedOut: function UserService_UserService$set_userLoggedOut(value) {
        this._userLoggedOut$1 = value;
        return value;
    },
    
    _fimsAdvertIDCookieName$1: '',
    
    get_fimsAdvertIDCookieName: function UserService_UserService$get_fimsAdvertIDCookieName() {
        return this._fimsAdvertIDCookieName$1;
    },
    set_fimsAdvertIDCookieName: function UserService_UserService$set_fimsAdvertIDCookieName(value) {
        this._fimsAdvertIDCookieName$1 = value;
        return value;
    },
    
    _fimsCookieValidLength$1: '',
    _sessionTimeoutPageArea$1: null,
    _personalDetails$1: null,
    
    get_username: function UserService_UserService$get_username() {
        if (!this._personalDetails$1) {
            return null;
        }
        return this._personalDetails$1.UserName;
    },
    
    get_personalDetails: function UserService_UserService$get_personalDetails() {
        return this._personalDetails$1;
    },
    
    _customerRegistrationDetails$1: null,
    
    onPageWillChange: function UserService_UserService$onPageWillChange() {
        UserService.UserService._log$1.debug('OnPageWillChange');
        this._environment.storeState(UserService.UserService._serviceName$1, { personalDetails: this._personalDetails$1 });
    },
    
    _navigationService$1: null,
    
    setNavigationService: function UserService_UserService$setNavigationService(navigationService) {
        UserService.UserService._log$1.debug('SetNavigationService');
        this._navigationService$1 = navigationService;
    },
    
    handleSessionTimeout: function UserService_UserService$handleSessionTimeout(exception) {
        UserService.UserService._log$1.debug('HandleSessionTimeout');
        if ((!exception || Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') && this._personalDetails$1) {
            this._personalDetails$1 = null;
            this._fireUserChangedEvent$1();
        }
    },
    
    init: function UserService_UserService$init(environment, parameters) {
        UserService.UserService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        UserService.UserService.callBase(this, 'init', [ environment, parameters ]);
        this._sessionTimeoutPageArea$1 = parameters['session-timeout-page-area'];
        this._fimsIDCookieName$1 = parameters['fimsid-cookie-name'];
        this._fimsAdvertIDCookieName$1 = parameters['fimsadvertid-cookie-name'];
        this._fimsCookieValidLength$1 = parameters['fims-cookie-duration'];
        this._userLoggedOut$1 = false;
        if (Object.keyExists(parameters, 'is-login-secure')) {
            this._isLoginSecure$1 = Boolean.parse(parameters['is-login-secure']);
        }
        if (Object.keyExists(parameters, 'allow-update-title')) {
            this._allowUpdateTitle$1 = Boolean.parse(parameters['allow-update-title']);
        }
        if (Object.keyExists(parameters, 'allow-update-DOB')) {
            this._allowUpdateDOB$1 = Boolean.parse(parameters['allow-update-DOB']);
        }
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(UserService.UserService._serviceName$1);
        if (state && Object.keyExists(state, 'personalDetails')) {
            this._personalDetails$1 = state['personalDetails'];
        }
        UserService.UserService._log$1.debug(String.format('Retrieving personalDetails, UserName= [{0}]', (!this._personalDetails$1) ? '' : this._personalDetails$1.UserName));
    },
    
    start: function UserService_UserService$start() {
        UserService.UserService._log$1.debug(String.format('Start IsLoggedIn={0}', this.isLoggedIn()));
        if (!this._personalDetails$1) {
            this.getPersonalDetailsIfLoggedIn(Delegate.create(this, function(result) {
            }), Delegate.create(this, function(exception) {
            }));
        }
        var fimsID = this._getFimsParameterValues$1(this._fimsIDCookieName$1);
        var fimsAdverID = this._getFimsParameterValues$1(this._fimsAdvertIDCookieName$1);
        if (!String.isNullOrEmpty(fimsID)) {
            if (String.isNullOrEmpty(this._fimsCookieValidLength$1)) {
                Framework.CookieUtil.setCookie(this._fimsIDCookieName$1, fimsID);
            }
            else {
                Framework.CookieUtil.setCookieWithDays(this._fimsIDCookieName$1, fimsID, Number.parse(this._fimsCookieValidLength$1));
            }
        }
        if (!String.isNullOrEmpty(fimsAdverID)) {
            Framework.CookieUtil.setCookie(this._fimsAdvertIDCookieName$1, fimsAdverID);
        }
    },
    
    _getFimsParameterValues$1: function UserService_UserService$_getFimsParameterValues$1(fimsParameter) {
        var fimsParameterValue = '';
        if (this._navigationService$1.getPageFilter()[fimsParameter]) {
            fimsParameterValue = this._navigationService$1.getPageFilter()[fimsParameter].toString();
        }
        else if (!String.isNullOrEmpty(Framework.CookieUtil.getCookie('_defaultAspxQuerystring')) && Framework.CookieUtil.getCookie('_defaultAspxQuerystring').toLowerCase().indexOf(fimsParameter.toLowerCase()) >= 0) {
            var cookieValue = Framework.CookieUtil.getCookie('_defaultAspxQuerystring').toLowerCase();
            var regex = new RegExp('(?:^|&)' + fimsParameter.toLowerCase() + '=(.*?)&');
            var cookieParse = regex.exec(cookieValue + '&');
            if (cookieParse && cookieParse.length === 2) {
                fimsParameterValue = cookieParse[1];
            }
            cookieValue = cookieValue.replace(String.format('{0}={1}', fimsParameter, fimsParameterValue), '');
            if (String.isNullOrEmpty(cookieValue)) {
                Framework.CookieUtil.clearCookie('_defaultAspxQuerystring');
            }
            else {
                Framework.CookieUtil.setCookie('_defaultAspxQuerystring', cookieValue);
            }
        }
        return fimsParameterValue;
    },
    
    registerUserChangedListener: function UserService_UserService$registerUserChangedListener(userChangedListener) {
        UserService.UserService._log$1.debug('RegisterUserChangedListener');
        this._userChangedListeners$1.registerListener(userChangedListener);
    },
    
    unregisterUserChangedListener: function UserService_UserService$unregisterUserChangedListener(userChangedListener) {
        UserService.UserService._log$1.debug('UnregisterUserChangedListener');
        this._userChangedListeners$1.unregisterListener(userChangedListener);
    },
    
    _fireUserChangedEvent$1: function UserService_UserService$_fireUserChangedEvent$1() {
        UserService.UserService._log$1.debug('FireUserChangedEvent');
        this._userChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onUserChanged(this);
        }));
    },
    
    registerUserPersonalDetailsChangedListener: function UserService_UserService$registerUserPersonalDetailsChangedListener(userPersonalDetailsChangedListener) {
        UserService.UserService._log$1.debug('RegisterUserPersonalDetailsChangedListener');
        this._userPersonalDetailsChangedListeners$1.registerListener(userPersonalDetailsChangedListener);
    },
    
    unregisterUserPersonalDetailsChangedListener: function UserService_UserService$unregisterUserPersonalDetailsChangedListener(UserPersonalDetailsChangedListener) {
        UserService.UserService._log$1.debug('UnregisterUserPersonalDetailsChangedListener');
        this._userPersonalDetailsChangedListeners$1.unregisterListener(UserPersonalDetailsChangedListener);
    },
    
    _fireUserPersonalDetailsChangedEvent$1: function UserService_UserService$_fireUserPersonalDetailsChangedEvent$1() {
        UserService.UserService._log$1.debug('FireUserPersonalDetailsChangedEvent');
        this._userPersonalDetailsChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onUserPersonalDetailsChanged(this);
        }));
    },
    
    registerUserRegisteredListener: function UserService_UserService$registerUserRegisteredListener(userRegisteredListener) {
        UserService.UserService._log$1.debug('RegisterUserRegisteredListener');
        this._userRegisteredListeners$1.registerListener(userRegisteredListener);
    },
    
    unregisterUserRegisteredListener: function UserService_UserService$unregisterUserRegisteredListener(userRegisteredListener) {
        UserService.UserService._log$1.debug('UnregisterUserRegisteredListener');
        this._userRegisteredListeners$1.unregisterListener(userRegisteredListener);
    },
    
    _fireUserRegisteredEvent$1: function UserService_UserService$_fireUserRegisteredEvent$1() {
        UserService.UserService._log$1.debug('FireUserRegisteredEvent');
        this._userRegisteredListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onUserRegistered();
        }));
    },
    
    registerPreRegisterCustomerListener: function UserService_UserService$registerPreRegisterCustomerListener(preRegisterCustomer) {
        UserService.UserService._log$1.debug('RegisterPreRegisterCustomerListener');
        this._preRegisterCustomerListeners$1.registerListener(preRegisterCustomer);
    },
    
    unregisterPreRegisterCustomerListener: function UserService_UserService$unregisterPreRegisterCustomerListener(preRegisterCustomer) {
        UserService.UserService._log$1.debug('UnregisterPreRegisterCustomerListener');
        this._preRegisterCustomerListeners$1.unregisterListener(preRegisterCustomer);
    },
    
    _firePreRegisterCustomerEvent$1: function UserService_UserService$_firePreRegisterCustomerEvent$1() {
        UserService.UserService._log$1.debug('FirePreRegisterCustomerEvent');
        this._preRegisterCustomerListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onPreRegisterCustomer(this);
        }));
    },
    
    registerCustomer: function UserService_UserService$registerCustomer(successCallback, failureCallback, customerRegistrationDetails, successAfterLoginCallback, failureAfterLoginCallback) {
        UserService.UserService._log$1.debug(String.format('RegisterCustomer customerRegistrationDetails=[{0}]', Framework.DictionaryUtil.dumpToString(customerRegistrationDetails)));
        this._customerRegistrationDetails$1 = customerRegistrationDetails;
        var fimsid = Framework.CookieUtil.getCookie(this._fimsIDCookieName$1);
        if (!String.isNullOrEmpty(fimsid)) {
            this._customerRegistrationDetails$1['SessionOrigin'] = fimsid;
        }
        this._firePreRegisterCustomerEvent$1();
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'RegisterCustomer', { customerRegistrationDetails: this._customerRegistrationDetails$1 }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this._fireUserRegisteredEvent$1();
            this.login(Delegate.create(this, function(loginResult) {
                if (successAfterLoginCallback) {
                    successAfterLoginCallback.invoke(loginResult);
                }
            }), Delegate.create(this, function(loginException) {
                if (failureAfterLoginCallback) {
                    successAfterLoginCallback.invoke(loginException);
                }
            }), this._customerRegistrationDetails$1['UserName'], this._customerRegistrationDetails$1['Password']);
        }), failureCallback);
    },
    
    upgradeCallCentreCustomer: function UserService_UserService$upgradeCallCentreCustomer(successCallback, failureCallback, upgradeCallCentreCustomerDetails) {
        UserService.UserService._log$1.debug(String.format('UpgradeCallCentreCustomer upgradeCallCentreCustomerDetails=[{0}]', Framework.DictionaryUtil.dumpObjectToString(upgradeCallCentreCustomerDetails)));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'UpgradeCallCentreCustomer', { upgradeCallCentreCustomerDetails: upgradeCallCentreCustomerDetails }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this.login(Delegate.create(this, function(loginResult) {
            }), Delegate.create(this, function(exception) {
            }), upgradeCallCentreCustomerDetails.UserName, upgradeCallCentreCustomerDetails.Password);
        }), failureCallback);
    },
    
    isUsernameAvailable: function UserService_UserService$isUsernameAvailable(successCallback, failureCallback, username) {
        UserService.UserService._log$1.debug(String.format('IsUsernameAvailable username=[{0}]', username));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'IsUsernameAvailable', { username: username }, successCallback, failureCallback);
    },
    
    isLoggedIn: function UserService_UserService$isLoggedIn() {
        UserService.UserService._log$1.debug('IsLoggedIn');
        return (this._personalDetails$1) ? true : false;
    },
    
    login: function UserService_UserService$login(successCallback, failureCallback, username, password) {
        UserService.UserService._log$1.debug(String.format('Login username=[{0}] password=[{1}]', username, password));
        this._environment.invokeAsyncUsingJsonp(UserService.UserService._serviceName$1, 'Login', { username: username, password: password }, Delegate.create(this, function(result) {
            this._personalDetails$1 = result;
            successCallback.invoke(result);
            this._fireUserChangedEvent$1();
            if (this._personalDetails$1.IsVerificationRequired) {
                this._navigationService$1.goTo('Accounting', { action: 'verify-customer' });
            }
        }), failureCallback, this._isLoginSecure$1);
    },
    
    loginWithCryptogram: function UserService_UserService$loginWithCryptogram(successCallback, failureCallback, username, passwordCryptogram) {
        UserService.UserService._log$1.debug(String.format('Login username=[{0}] passwordCryptogram=[{1}]', username, passwordCryptogram));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'LoginWithCryptogram', { username: username, passwordCryptogram: passwordCryptogram }, Delegate.create(this, function(result) {
            this._personalDetails$1 = result;
            successCallback.invoke(result);
            this._fireUserChangedEvent$1();
            if (this._personalDetails$1.IsVerificationRequired) {
                this._navigationService$1.goTo('Accounting', { action: 'verify-customer' });
            }
        }), failureCallback);
    },
    
    logout: function UserService_UserService$logout(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('Logout');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'Logout', {}, Delegate.create(this, function(result) {
            this._personalDetails$1 = null;
            this._userLoggedOut$1 = true;
            successCallback.invoke(result);
            this._fireUserChangedEvent$1();
        }), Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug(String.format('Error while logging out errorMessage = [{0}]', Framework.ExceptionUtil.getExceptionDetails(exception).get_message()));
            this._personalDetails$1 = null;
            this._userLoggedOut$1 = true;
            failureCallback.invoke(exception);
            this._fireUserChangedEvent$1();
        }));
    },
    
    setPassword: function UserService_UserService$setPassword(successCallback, failureCallback, oldPassword, password) {
        UserService.UserService._log$1.debug(String.format('SetPassword oldPassword=[{0}] password=[{1}]', oldPassword, password));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'SetPassword', { oldPassword: oldPassword, password: password }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('SetPassword exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    getPasswordCryptogram: function UserService_UserService$getPasswordCryptogram(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('GetPasswordCryptogram');
        if (this.isLoggedIn()) {
            this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetPasswordCryptogram', {}, successCallback, failureCallback);
        }
    },
    
    getSecretQuestion: function UserService_UserService$getSecretQuestion(successCallback, failureCallback, userName, dateOfBirth) {
        UserService.UserService._log$1.debug(String.format('GetSecretQuestion userName=[{0}] dateOfBirth=[{1}]', userName, dateOfBirth));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetSecretQuestion', { username: userName, dateOfBirth: Framework.JSONFormat.formatDateTime(dateOfBirth) }, successCallback, failureCallback);
    },
    
    setPasswordUsingSecretAnswer: function UserService_UserService$setPasswordUsingSecretAnswer(successCallback, failureCallback, username, answer, password, IDDCSecretQuestion) {
        UserService.UserService._log$1.debug(String.format('SetPassword userName=[{0}] answer=[{1}] password=[{2}] IDDCSecretQuestion=[{3}]', username, answer, password, IDDCSecretQuestion));
        var dictionary = { username: username, answer: answer, password: password, IDDCSecretQuestion: IDDCSecretQuestion };
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'SetPasswordUsingSecretAnswer', dictionary, successCallback, failureCallback);
    },
    
    resetPassword: function UserService_UserService$resetPassword(successCallback, failureCallback, username, dateOfBirth) {
        UserService.UserService._log$1.debug(String.format('ResetPassword userName=[{0}] dateOfBirth=[{1}]', username, dateOfBirth));
        var dictionary = { username: username, dateOfBirth: Framework.JSONFormat.formatDateTime(dateOfBirth) };
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'ResetPassword', dictionary, successCallback, failureCallback);
    },
    
    getTempSession4PasswordReset: function UserService_UserService$getTempSession4PasswordReset(successCallback, failureCallback, username, email) {
        UserService.UserService._log$1.debug(String.format('GetTempSession4PasswordReset username=[{0}] email=[{1}]', username, email));
        var dictionary = { IDMDLanguage: this._environment.getLanguage(), username: username, email: email };
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetTempSessionForPasswordReset', dictionary, successCallback, failureCallback);
    },
    
    isVerified: function UserService_UserService$isVerified(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('IsVerified');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'IsVerified', {}, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('IsVerified exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    startVerification: function UserService_UserService$startVerification(successCallback, failureCallback, IDMMCVType, detailsToBeVerified) {
        UserService.UserService._log$1.debug(String.format('StartVerification IDMMCVType=[{0}] detailsToBeVerified=[{1}]', IDMMCVType, detailsToBeVerified));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'StartVerification', { IDMMCVType: IDMMCVType, detailsToBeVerified: detailsToBeVerified }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('StartVerification exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    completeVerification: function UserService_UserService$completeVerification(successCallback, failureCallback, verificationCodeEntered) {
        UserService.UserService._log$1.debug(String.format('CompleteVerification verificationCodeEntered=[{0}]', verificationCodeEntered));
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'CompleteVerification', { verificationCodeEntered: verificationCodeEntered }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('CompleteVerification exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    getPersonalDetails: function UserService_UserService$getPersonalDetails(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('GetPersonalDetails');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetPersonalDetails', {}, Delegate.create(this, function(result) {
            var personalDetails = result;
            var changed = false;
            if (personalDetails) {
                changed = !this._personalDetails$1 || this._personalDetails$1.UserName !== personalDetails.UserName;
            }
            else {
                changed = this._personalDetails$1;
            }
            this._personalDetails$1 = personalDetails;
            successCallback.invoke(result);
            if (changed) {
                this._fireUserChangedEvent$1();
            }
        }), Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('GetPersonalDetails exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    getIDMMCustomer: function UserService_UserService$getIDMMCustomer(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('GetIDMMCustomer');
        if (this.isLoggedIn()) {
            this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetIDMMCustomer', {}, successCallback, failureCallback);
        }
    },
    
    getPersonalDetailsIfLoggedIn: function UserService_UserService$getPersonalDetailsIfLoggedIn(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('GetPersonalDetailsIfLoggedIn');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetPersonalDetailsIfLoggedIn', {}, Delegate.create(this, function(result) {
            var personalDetails = result;
            var changed = false;
            if (personalDetails) {
                changed = !this._personalDetails$1 || this._personalDetails$1.UserName !== personalDetails.UserName;
            }
            else {
                changed = this._personalDetails$1;
            }
            this._personalDetails$1 = personalDetails;
            successCallback.invoke(result);
            if (changed) {
                this._fireUserChangedEvent$1();
            }
        }), Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('GetPersonalDetailsIfLoggedIn exception ' + exception.message);
            failureCallback.invoke(exception);
        }));
    },
    
    updatePersonalDetails: function UserService_UserService$updatePersonalDetails(successCallback, failureCallback, personalDetails) {
        UserService.UserService._log$1.debug(String.format('UpdatePersonalDetails personalDetails=[{0}]', Framework.DictionaryUtil.dumpToString(personalDetails)));
        if (!this._allowUpdateTitle$1 || !personalDetails['Title']) {
            personalDetails['Title'] = this._personalDetails$1.Title;
        }
        if (!this._allowUpdateDOB$1 || !personalDetails['DateOfBirth']) {
            personalDetails['DateOfBirth'] = this._personalDetails$1.DateOfBirth;
        }
        if (!Object.keyExists(personalDetails, 'IDMMGender')) {
            personalDetails['IDMMGender'] = this._personalDetails$1.IDMMGender;
        }
        if (!Object.keyExists(personalDetails, 'FirstName')) {
            personalDetails['FirstName'] = this._personalDetails$1.FirstName;
        }
        if (!Object.keyExists(personalDetails, 'LastName')) {
            personalDetails['LastName'] = this._personalDetails$1.LastName;
        }
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'UpdatePersonalDetails', { personalDetails: personalDetails }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this._fireUserPersonalDetailsChangedEvent$1();
        }), Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('UpdatePersonalDetails exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    updatePersonalDetailsExt: function UserService_UserService$updatePersonalDetailsExt(successCallback, failureCallback, personalDetails, password) {
        UserService.UserService._log$1.debug(String.format('UpdatePersonalDetails personalDetails=[{0}]', Framework.DictionaryUtil.dumpToString(personalDetails)));
        if (!this._allowUpdateTitle$1 || !personalDetails['Title']) {
            personalDetails['Title'] = this._personalDetails$1.Title;
        }
        if (!this._allowUpdateDOB$1 || !personalDetails['DateOfBirth']) {
            personalDetails['DateOfBirth'] = this._personalDetails$1.DateOfBirth;
        }
        if (!Object.keyExists(personalDetails, 'IDMMGender')) {
            personalDetails['IDMMGender'] = this._personalDetails$1.IDMMGender;
        }
        if (!Object.keyExists(personalDetails, 'FirstName')) {
            personalDetails['FirstName'] = this._personalDetails$1.FirstName;
        }
        if (!Object.keyExists(personalDetails, 'LastName')) {
            personalDetails['LastName'] = this._personalDetails$1.LastName;
        }
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'UpdatePersonalDetailsExt', { personalDetails: personalDetails, password: password }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this._fireUserPersonalDetailsChangedEvent$1();
        }), Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('UpdatePersonalDetails exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    updateExtendedPersonalDetails: function UserService_UserService$updateExtendedPersonalDetails(successCallback, failureCallback, personalDetails) {
        UserService.UserService._log$1.debug(String.format('UpdateExtendedPersonalDetails personalDetails=[{0}]', Framework.DictionaryUtil.dumpToString(personalDetails)));
        if (!Object.keyExists(personalDetails, 'IVRPin')) {
            personalDetails['IVRPin'] = '';
        }
        if (!Object.keyExists(personalDetails, 'Title')) {
            personalDetails['Title'] = this._personalDetails$1.Title;
        }
        if (!Object.keyExists(personalDetails, 'IDMMGender')) {
            personalDetails['IDMMGender'] = this._personalDetails$1.IDMMGender;
        }
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'UpdateExtendedPersonalDetails', { personalDetails: personalDetails }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('UpdateExtendedPersonalDetails exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    getCustomerSessionDuration: function UserService_UserService$getCustomerSessionDuration(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('GetCustomerSessionDuration');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetCustomerSessionDuration', {}, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('GetCustomerSessionDuration exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    setPlayerProtection: function UserService_UserService$setPlayerProtection(successCallback, failureCallback, playerProtectionDetails) {
        UserService.UserService._log$1.debug('SetPlayerProtection');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'SetPlayerProtection', { playerProtectionDetails: playerProtectionDetails }, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('SetPlayerProtection exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    getPlayerProtection: function UserService_UserService$getPlayerProtection(successCallback, failureCallback) {
        UserService.UserService._log$1.debug('GetPlayerProtection');
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'GetPlayerProtection', {}, successCallback, Delegate.create(this, function(exception) {
            UserService.UserService._log$1.debug('GetPlayerProtection exception ' + exception.message);
            failureCallback.invoke(exception);
            this.handleSessionTimeout(exception);
        }));
    },
    
    _getIntegration$1: function UserService_UserService$_getIntegration$1(integrations, integrationName) {
        var integration = null;
        var $enum1 = integrations.getEnumerator();
        while ($enum1.moveNext()) {
            var item = $enum1.get_current();
            if (Object.keyExists(item, UserService.UserService._nameConst$1) && String.equals(item[UserService.UserService._nameConst$1].toString(), integrationName, false)) {
                integration = item;
                break;
            }
        }
        if (!integration) {
            integration = {};
            integration[UserService.UserService._nameConst$1] = integrationName;
            integration[UserService.UserService._propertiesConst$1] = {};
        }
        return integration;
    },
    
    _setIntegration$1: function UserService_UserService$_setIntegration$1(integrations, integrationName, integration) {
        var item = null;
        var found = false;
        for (var i = 0; i < integrations.length; i++) {
            item = integrations[i];
            if (Object.keyExists(item, UserService.UserService._nameConst$1) && String.equals(item[UserService.UserService._nameConst$1].toString(), integrationName, false)) {
                integrations[i] = integration;
                found = true;
                break;
            }
        }
        if (!found) {
            integrations.add(integration);
        }
    },
    
    setIntegrationDetails: function UserService_UserService$setIntegrationDetails(integrationName, propertyName, propertyValue) {
        UserService.UserService._log$1.debug('SetIntegrationDetails');
        var integrations;
        var integration;
        var properties = null;
        if (Object.keyExists(this._customerRegistrationDetails$1, UserService.UserService._integrationDetailsConst$1)) {
            integrations = this._customerRegistrationDetails$1[UserService.UserService._integrationDetailsConst$1];
        }
        else {
            integrations = [];
        }
        integration = this._getIntegration$1(integrations, integrationName);
        properties = integration[UserService.UserService._propertiesConst$1];
        properties[propertyName] = (propertyValue) ? propertyValue : '';
        integration[UserService.UserService._propertiesConst$1] = properties;
        this._setIntegration$1(integrations, integrationName, integration);
        this._customerRegistrationDetails$1[UserService.UserService._integrationDetailsConst$1] = integrations;
    },
    
    contactUsViaEmail: function UserService_UserService$contactUsViaEmail(successCallback, failureCallback, subject, email, body) {
        var oBody = '';
        var i = 0;
        var $dict1 = body;
        for (var $key2 in $dict1) {
            var oEntry = { key: $key2, value: $dict1[$key2] };
            var separator = (!i) ? '' : '|';
            oBody = oBody + separator + oEntry.value;
            i++;
        }
        this._environment.invokeAsync(UserService.UserService._serviceName$1, 'sendContactUsEmail', { subject: subject, email: email, body: oBody }, successCallback, failureCallback);
    }
}


////////////////////////////////////////////////////////////////////////////////
// UserService.PersonalDetails

UserService.PersonalDetails = function UserService_PersonalDetails() {
}
UserService.PersonalDetails.prototype = {
    City: null,
    CountyOrStateOrProvince: null,
    FirstName: null,
    FullName: null,
    HomePhone: null,
    IDMMCountry: null,
    LastName: null,
    MiddleNames: null,
    MobilePhone: null,
    PostCode: null,
    PrimaryEmail: null,
    StreetAddress: null,
    Title: null,
    UserName: null,
    DateOfBirth: null,
    IsVerificationRequired: false,
    ResetPasswordRequired: null,
    ExpiredPwdChangeMethod: null,
    IDMMGender: null
}


UserService.PlayerProtectionDetails.createClass('UserService.PlayerProtectionDetails');
UserService.UpgradeCallCentreCustomerDetails.createClass('UserService.UpgradeCallCentreCustomerDetails');
UserService.UserService.createClass('UserService.UserService', Framework.AbstractService, Framework.IPageWillChangeListener);
UserService.PersonalDetails.createClass('UserService.PersonalDetails');
UserService.UserService._serviceName$1 = 'UserService';
UserService.UserService._integrationDetailsConst$1 = 'IntegrationDetails';
UserService.UserService._nameConst$1 = 'Name';
UserService.UserService._propertiesConst$1 = 'Properties';
UserService.UserService._log$1 = Framework.Logger.getLog(UserService.UserService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('AccountService');

////////////////////////////////////////////////////////////////////////////////
// AccountService.IAccountPreferencesChangedListener

AccountService.IAccountPreferencesChangedListener = function() { };
AccountService.IAccountPreferencesChangedListener.prototype = {
    onAccountPreferencesChanged : null
}
AccountService.IAccountPreferencesChangedListener.createInterface('AccountService.IAccountPreferencesChangedListener');


////////////////////////////////////////////////////////////////////////////////
// AccountService.IBalanceChangedListener

AccountService.IBalanceChangedListener = function() { };
AccountService.IBalanceChangedListener.prototype = {
    onBalanceChanged : null
}
AccountService.IBalanceChangedListener.createInterface('AccountService.IBalanceChangedListener');


////////////////////////////////////////////////////////////////////////////////
// AccountService.IDepositExecutedListener

AccountService.IDepositExecutedListener = function() { };
AccountService.IDepositExecutedListener.prototype = {
    onDepositExecuted : null
}
AccountService.IDepositExecutedListener.createInterface('AccountService.IDepositExecutedListener');


////////////////////////////////////////////////////////////////////////////////
// AccountService.AccountPreferences

AccountService.AccountPreferences = function AccountService_AccountPreferences(isAccountBalanceConstantlyDisplayed, isCallCentreAccountNumberConstantlyDisplayed, promotionalEmailFormat, idDCSecretQuestion, secretQuestion, secretAnswer, isNoCorrespondence, preferredMethodIncludesEmail, preferredMethodIncludesPhone, preferredMethodIncludesPost, preferredMethodIncludesSms) {
    this.IsAccountBalanceConstantlyDisplayed = isAccountBalanceConstantlyDisplayed;
    this.IsCallCentreAccountNumberConstantlyDisplayed = isCallCentreAccountNumberConstantlyDisplayed;
    this.PromotionalEmailFormat = (promotionalEmailFormat !== AccountService.AccountPreferences.plainText && promotionalEmailFormat !== AccountService.AccountPreferences.html && promotionalEmailFormat !== AccountService.AccountPreferences.dontSend) ? AccountService.AccountPreferences.defaultType : promotionalEmailFormat;
    this.IsNoCorrespondence = isNoCorrespondence;
    this.IDDCSecretQuestion = idDCSecretQuestion;
    this.SecretQuestion = secretQuestion;
    this.SecretAnswer = secretAnswer;
    this.PreferredMethodIncludesEmail = preferredMethodIncludesEmail;
    this.PreferredMethodIncludesPhone = preferredMethodIncludesPhone;
    this.PreferredMethodIncludesPost = preferredMethodIncludesPost;
    this.PreferredMethodIncludesSms = preferredMethodIncludesSms;
}
AccountService.AccountPreferences.equals = function AccountService_AccountPreferences$equals(preferences1, preferences2) {
    if (!preferences1 && !preferences2) {
        return true;
    }
    if (!preferences1 && preferences2) {
        return false;
    }
    if (preferences1 && !preferences2) {
        return false;
    }
    if (preferences1.IsAccountBalanceConstantlyDisplayed !== preferences2.IsAccountBalanceConstantlyDisplayed) {
        return false;
    }
    if (preferences1.IsCallCentreAccountNumberConstantlyDisplayed !== preferences2.IsCallCentreAccountNumberConstantlyDisplayed) {
        return false;
    }
    if (preferences1.IsNoCorrespondence !== preferences2.IsNoCorrespondence) {
        return false;
    }
    if (!String.equals(preferences1.PromotionalEmailFormat, preferences2.PromotionalEmailFormat, true)) {
        return false;
    }
    if (!String.equals(preferences1.IDDCSecretQuestion, preferences2.IDDCSecretQuestion, true)) {
        return false;
    }
    if (!String.equals(preferences1.SecretQuestion, preferences2.SecretQuestion, true)) {
        return false;
    }
    if (!String.equals(preferences1.SecretAnswer, preferences2.SecretAnswer, true)) {
        return false;
    }
    if (preferences1.PreferredMethodIncludesEmail !== preferences2.PreferredMethodIncludesEmail) {
        return false;
    }
    if (preferences1.PreferredMethodIncludesPhone !== preferences2.PreferredMethodIncludesPhone) {
        return false;
    }
    if (preferences1.PreferredMethodIncludesPost !== preferences2.PreferredMethodIncludesPost) {
        return false;
    }
    if (preferences1.PreferredMethodIncludesSms !== preferences2.PreferredMethodIncludesSms) {
        return false;
    }
    return true;
}
AccountService.AccountPreferences.prototype = {
    IsAccountBalanceConstantlyDisplayed: false,
    IsCallCentreAccountNumberConstantlyDisplayed: false,
    PromotionalEmailFormat: null,
    IDDCSecretQuestion: null,
    SecretQuestion: null,
    SecretAnswer: null,
    IsNoCorrespondence: false,
    PreferredMethodIncludesEmail: false,
    PreferredMethodIncludesSms: false,
    PreferredMethodIncludesPost: false,
    PreferredMethodIncludesPhone: false
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.AccountService

AccountService.AccountService = function AccountService_AccountService() {
    this._accountPreferencesChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._balanceChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._depositExecutedListener$1 = new Framework.ListenerInvoker(true);
    AccountService.AccountService.constructBase(this);
    AccountService.AccountService._log$1.debug('ctor');
}
AccountService.AccountService.prototype = {
    _preferences$1: null,
    _accountsDetails$1: null,
    httpsMethods: null,
    
    _getState$1: function AccountService_AccountService$_getState$1() {
        return { preferences: this._preferences$1, accountsDetails: this._accountsDetails$1 };
    },
    
    init: function AccountService_AccountService$init(environment, parameters) {
        AccountService.AccountService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        AccountService.AccountService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(AccountService.AccountService._serviceName$1);
        if (state && Object.keyExists(state, 'preferences')) {
            this._preferences$1 = state['preferences'];
        }
        else {
            this._preferences$1 = this._getDefaultPreferences$1();
        }
        if (state && Object.keyExists(state, 'accountsDetails')) {
            this._accountsDetails$1 = state['accountsDetails'];
        }
        if (Object.keyExists(parameters, 'https-methods')) {
            this.httpsMethods = (parameters['https-methods']).split(',');
        }
    },
    
    start: function AccountService_AccountService$start() {
        AccountService.AccountService._log$1.debug('Start');
    },
    
    onPageWillChange: function AccountService_AccountService$onPageWillChange() {
        AccountService.AccountService._log$1.debug('OnPageWillChange');
        this._environment.storeState(AccountService.AccountService._serviceName$1, this._getState$1());
    },
    
    _userService$1: null,
    
    setUserService: function AccountService_AccountService$setUserService(userService) {
        AccountService.AccountService._log$1.debug('SetUserService');
        this._userService$1 = userService;
        this._userService$1.registerUserChangedListener(this);
    },
    
    onUserChanged: function AccountService_AccountService$onUserChanged(eventSource) {
        AccountService.AccountService._log$1.debug('OnUserChanged');
        if (this._userService$1.isLoggedIn()) {
            this._accountsDetails$1 = null;
            this._preferences$1 = null;
            this.fetchPreferences(null, null);
            this.fetchAccountsDetails();
        }
        else {
            this._preferences$1 = this._getDefaultPreferences$1();
            this._accountsDetails$1 = null;
            this._fireBalanceChangedEvent$1();
        }
    },
    
    registerAccountPreferencesChangedListener: function AccountService_AccountService$registerAccountPreferencesChangedListener(accountPreferencesChangedListener) {
        AccountService.AccountService._log$1.debug('RegisterAccountPreferencesChangedListener');
        this._accountPreferencesChangedListeners$1.registerListener(accountPreferencesChangedListener);
    },
    
    unregisterAccountPreferencesChangedListener: function AccountService_AccountService$unregisterAccountPreferencesChangedListener(accountPreferencesChangedListener) {
        AccountService.AccountService._log$1.debug('UnregisterAccountPreferencesChangedListener');
        this._accountPreferencesChangedListeners$1.unregisterListener(accountPreferencesChangedListener);
    },
    
    _fireAccountPreferencesChangedEvent$1: function AccountService_AccountService$_fireAccountPreferencesChangedEvent$1() {
        AccountService.AccountService._log$1.debug('FireAccountPreferencesChangedEvent');
        this._accountPreferencesChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onAccountPreferencesChanged(this);
        }));
    },
    
    registerBalanceChangedListener: function AccountService_AccountService$registerBalanceChangedListener(listener) {
        AccountService.AccountService._log$1.debug('RegisterBalanceChangedListener');
        this._balanceChangedListeners$1.registerListener(listener);
    },
    
    unregisterBalanceChangedListener: function AccountService_AccountService$unregisterBalanceChangedListener(listener) {
        AccountService.AccountService._log$1.debug('UnregisterBalanceChangedListener');
        this._balanceChangedListeners$1.unregisterListener(listener);
    },
    
    _fireBalanceChangedEvent$1: function AccountService_AccountService$_fireBalanceChangedEvent$1() {
        AccountService.AccountService._log$1.debug('FireBalanceChangedEvent');
        this._balanceChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBalanceChanged(this);
        }));
    },
    
    registerDepositExecutedListener: function AccountService_AccountService$registerDepositExecutedListener(listener) {
        AccountService.AccountService._log$1.debug('RegisterDepositExecutedListener');
        this._depositExecutedListener$1.registerListener(listener);
    },
    
    unregisterDepositExecutedListener: function AccountService_AccountService$unregisterDepositExecutedListener(listener) {
        AccountService.AccountService._log$1.debug('UnregisterDepositExecutedListener');
        this._depositExecutedListener$1.unregisterListener(listener);
    },
    
    _fireDepositExecutedEvent$1: function AccountService_AccountService$_fireDepositExecutedEvent$1() {
        AccountService.AccountService._log$1.debug('FireDepositExecutedEvent');
        this._depositExecutedListener$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onDepositExecuted(this);
        }));
    },
    
    getCurrencySimbol: function AccountService_AccountService$getCurrencySimbol() {
        if (!this._accountsDetails$1 || !this._accountsDetails$1.length) {
            return null;
        }
        return this._accountsDetails$1[0].CurrencyNotation;
    },
    
    getCurrencySimbolHTML: function AccountService_AccountService$getCurrencySimbolHTML() {
        if (!this._accountsDetails$1 || !this._accountsDetails$1.length) {
            return null;
        }
        return this._accountsDetails$1[0].CurrencyHtmlNotation;
    },
    
    get_accountsDetails: function AccountService_AccountService$get_accountsDetails() {
        return this._accountsDetails$1;
    },
    
    get_creditAccountDetails: function AccountService_AccountService$get_creditAccountDetails() {
        var details = this._accountsDetails$1;
        if (details) {
            for (var i = 0; i < details.length; i++) {
                if (!String.compare(details[i].IDMMAccountClass, 'credit', true)) {
                    return details[i];
                }
            }
        }
        return null;
    },
    
    get_freeAccountDetails: function AccountService_AccountService$get_freeAccountDetails() {
        var details = this._accountsDetails$1;
        if (details) {
            for (var i = 0; i < details.length; i++) {
                if (!String.compare(details[i].IDMMAccountClass, 'free', true)) {
                    return details[i];
                }
            }
        }
        return null;
    },
    
    fetchAccountsDetails: function AccountService_AccountService$fetchAccountsDetails() {
        AccountService.AccountService._log$1.debug('GetAccountsDetails');
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetAccountsDetails', {}, Delegate.create(this, function(result) {
            if (result) {
                var hasChanged = !AccountService.AccountDetails.equalsArray(this._accountsDetails$1, result);
                this._accountsDetails$1 = result;
                if (hasChanged) {
                    this._fireBalanceChangedEvent$1();
                }
            }
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetAccountsDetails exception' + exception.message);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getBalanceHistory: function AccountService_AccountService$getBalanceHistory(successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc) {
        AccountService.AccountService._log$1.debug(String.format('GetBalanceHistory from=[{0}] to=[{1}] pageNumber=[{2}] pageSize=[{3}] orderBy=[{4}] orderDesc=[{5}]', successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetBalanceHistory', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetBalanceHistory exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getBalanceHistoryFiltered: function AccountService_AccountService$getBalanceHistoryFiltered(successCallback, failureCallback, from, to, IncludeTxTypes, ExcludeTxTypes, IncludeTxClasses, ExcludeTxClasses, pageNumber, pageSize, orderBy, orderDesc) {
        AccountService.AccountService._log$1.debug(String.format('GetBalanceHistory from=[{0}] to=[{1}] includeTxType[{6}] excludeTxType[{7}] includeTxClasses[{8}] excludeTxClasses[{9}] pageNumber=[{2}] pageSize=[{3}] orderBy=[{4}] orderDesc=[{5}]', successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, (!IncludeTxTypes) ? String.Empty : IncludeTxTypes.join(','), (!ExcludeTxTypes) ? String.Empty : ExcludeTxTypes.join(','), (!IncludeTxClasses) ? String.Empty : IncludeTxClasses.join(','), (!ExcludeTxClasses) ? String.Empty : ExcludeTxClasses.join(',')));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetBalanceHistoryFiltered', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), IncludeTxTypes: IncludeTxTypes, ExcludeTxTypes: ExcludeTxTypes, IncludeTxClasses: IncludeTxClasses, ExcludeTxClasses: ExcludeTxClasses, pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetBalanceHistory exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getBalanceHistoryWithNumberOfRecords: function AccountService_AccountService$getBalanceHistoryWithNumberOfRecords(successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, numberOfRecords) {
        AccountService.AccountService._log$1.debug(String.format('GetBalanceHistoryWithNumberOfRecords from=[{0}] to=[{1}] pageNumber=[{2}] pageSize=[{3}] orderBy=[{4}] orderDesc=[{5}] numberOfRecords=[{6}]', successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, numberOfRecords));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetBalanceHistoryWithNumberOfRecords', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc, numberOfRecords: numberOfRecords }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetBalanceHistory exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getBalanceHistoryFilteredWithNumberOfRecords: function AccountService_AccountService$getBalanceHistoryFilteredWithNumberOfRecords(successCallback, failureCallback, from, to, IncludeTxTypes, ExcludeTxTypes, IncludeTxClasses, ExcludeTxClasses, pageNumber, pageSize, orderBy, orderDesc, numberOfRecords) {
        AccountService.AccountService._log$1.debug(String.format('GetBalanceHistoryWithNumberOfRecords from=[{0}] to=[{1}] pageNumber=[{2}] pageSize=[{3}] orderBy=[{4}] orderDesc=[{5}] numberOfRecords=[{6}] inclideTxTypes=[{7}] excludeTXTypes =[{8}] includeTxClasses=[{9}] excludeTxClasses=[{10}]', successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, numberOfRecords, (!IncludeTxTypes) ? String.Empty : IncludeTxTypes.join(','), (!ExcludeTxTypes) ? String.Empty : ExcludeTxTypes.join(','), (!IncludeTxClasses) ? String.Empty : IncludeTxClasses.join(','), (!ExcludeTxClasses) ? String.Empty : ExcludeTxClasses.join(',')));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetBalanceHistoryFilteredWithNumberOfRecords', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), IncludeTxTypes: IncludeTxTypes, ExcludeTxTypes: ExcludeTxTypes, IncludeTxClasses: IncludeTxClasses, ExcludeTxClasses: ExcludeTxClasses, pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc, numberOfRecords: numberOfRecords }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetBalanceHistory exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getAllowedPaymentTypes: function AccountService_AccountService$getAllowedPaymentTypes(successCallback, failureCallback, IDMDLanguage) {
        AccountService.AccountService._log$1.debug(String.format('GetAllowedPaymentTypes IDMDLanguage=[{0}]', IDMDLanguage));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetAllowedPaymentTypes', { IDMDLanguage: IDMDLanguage }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetAllowedPaymentTypes exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getRegisteredSettlementInstructions: function AccountService_AccountService$getRegisteredSettlementInstructions(successCallback, failureCallback, IDMMSITransactionType) {
        AccountService.AccountService._log$1.debug(String.format('GetRegisteredSettlementInstructions IDMMSITransactionType=[{0}]', IDMMSITransactionType));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetActivePaymentInstruments', { IDMMSITransactionType: IDMMSITransactionType }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetRegisteredSettlementInstructions exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getPaymentInstrument: function AccountService_AccountService$getPaymentInstrument(successCallback, failureCallback, IDMMSIInstruction) {
        AccountService.AccountService._log$1.debug(String.format('GetPaymentInstrument IDMMSIInstruction=[{0}]', IDMMSIInstruction));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetPaymentInstrument', { IDMMSIInstruction: IDMMSIInstruction }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetPaymentInstrument exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getPaymentType: function AccountService_AccountService$getPaymentType(successCallback, failureCallback, IDMMSIType) {
        AccountService.AccountService._log$1.debug(String.format('GetPaymentType IDMMSIType=[{0}]', IDMMSIType));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetPaymentType', { IDMMSIType: IDMMSIType }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetPaymentType exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    registerCard: function AccountService_AccountService$registerCard(successCallback, failureCallback, card) {
        AccountService.AccountService._log$1.debug(String.format('RegisterCard card=[{0}]', Framework.DictionaryUtil.dumpToString(card)));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'RegisterCard', { card: card }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('RegisterCard exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    registerPPCard: function AccountService_AccountService$registerPPCard(successCallback, failureCallback, cardNumber, cardKey) {
        AccountService.AccountService._log$1.debug(String.format('RegisterPPCard cardNumber=[{0}] cardKey=[{1}]', cardNumber, cardKey));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'RegisterPPCard', { IDMDLanguage: this._environment.getLanguage(), cardNumber: cardNumber, cardKey: cardKey }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this.fetchAccountsDetails();
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('RegisterPPCard exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    registerCheque: function AccountService_AccountService$registerCheque(successCallback, failureCallback, cheque) {
        AccountService.AccountService._log$1.debug(String.format('RegisterCheque cheque=[{0}]', Framework.DictionaryUtil.dumpToString(cheque)));
        if (!Object.keyExists(cheque, 'IDMMSIType')) {
            cheque['IDMMSIType'] = 'CHEQUE';
        }
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'RegisterCheque', { cheque: cheque }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('RegisterCheque exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    registerBankTransfer: function AccountService_AccountService$registerBankTransfer(successCallback, failureCallback, bankTransfer) {
        AccountService.AccountService._log$1.debug(String.format('RegisterBankTransfer bankTransfer=[{0}]', Framework.DictionaryUtil.dumpToString(bankTransfer)));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'RegisterBankTransfer', { bankTransfer: bankTransfer }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('RegisterBankTransfer exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    registerRedirectBasedWallet: function AccountService_AccountService$registerRedirectBasedWallet(successCallback, failureCallback, redirectBasedWallet) {
        AccountService.AccountService._log$1.debug(String.format('RegisterRedirectBasedWallet redirectBasedWallet=[{0}]', Framework.DictionaryUtil.dumpToString(redirectBasedWallet)));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'RegisterRedirectBasedWallet', { redirectBasedWallet: redirectBasedWallet }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('RegisterRedirectBasedWallet exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    updateCreditCardDetails: function AccountService_AccountService$updateCreditCardDetails(successCallback, failureCallback, creditCardUpdate) {
        AccountService.AccountService._log$1.debug(String.format('UpdateCreditCardDetails creditCardUpdate=[{0}]', Framework.DictionaryUtil.dumpToString(creditCardUpdate)));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'UpdateCreditCardDetails', { creditCardUpdate: creditCardUpdate }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('UpdateCreditCardDetails exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    beginSettlementInstructionTransaction: function AccountService_AccountService$beginSettlementInstructionTransaction(successCallback, failureCallback, password, IDMMSITransactionType, IDMMSIInstruction, amount, securityCode) {
        AccountService.AccountService._log$1.debug(String.format('BeginSettlementInstructionTransaction password=[{0}] IDMMSITransactionType=[{1}] IDMMSIInstruction=[{2}] amount=[{3}] securityCode=[{4}]', password, IDMMSITransactionType, IDMMSIInstruction, amount, securityCode));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'BeginPaymentTransaction', { password: password, IDMMSITransactionType: IDMMSITransactionType, IDMMSIInstruction: IDMMSIInstruction, amount: amount, securityCode: (String.isNullOrEmpty(securityCode)) ? null : securityCode }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('BeginSettlementInstructionTransaction exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    beginSettlementInstructionTransactionWithoutPassword: function AccountService_AccountService$beginSettlementInstructionTransactionWithoutPassword(successCallback, failureCallback, IDMMSITransactionType, IDMMSIInstruction, amount, securityCode) {
        AccountService.AccountService._log$1.debug(String.format('BeginSettlementInstructionTransactionWithoutPassword IDMMSITransactionType=[{0}] IDMMSIInstruction=[{1}] amount=[{2}] securityCode=[{3}]', IDMMSITransactionType, IDMMSIInstruction, amount, securityCode));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'BeginPaymentTransactionWithoutPassword', { IDMMSITransactionType: IDMMSITransactionType, IDMMSIInstruction: IDMMSIInstruction, amount: amount, securityCode: (String.isNullOrEmpty(securityCode)) ? null : securityCode }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('BeginSettlementInstructionTransaction exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getRBWRequest: function AccountService_AccountService$getRBWRequest(successCallback, failureCallback, IDMMSITXRequest, returnUrl, language, description) {
        AccountService.AccountService._log$1.debug(String.format('GetRBWRequest IDMMSITXRequest=[{0}] returnUrl=[{1}] language=[{2}] description=[{3}]', IDMMSITXRequest, returnUrl, language, description));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetRBWRequest', { IDMMSITXRequest: IDMMSITXRequest, returnUrl: returnUrl, language: language, description: description }, successCallback, Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetRBWRequest exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    getSettlementInstructionTransactionState: function AccountService_AccountService$getSettlementInstructionTransactionState(successCallback, failureCallback, IDMMSITXRequest) {
        AccountService.AccountService._log$1.debug(String.format('GetSettlementInstructionTransactionState IDMMSITXRequest=[{0}]', IDMMSITXRequest));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'GetPaymentTransaction', { IDMMSITXRequest: IDMMSITXRequest }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            var isSuccess = (result)['IsSuccess'];
            var transactionState = (result)['IDMMSITransactionState'];
            if (isSuccess) {
                this.fetchAccountsDetails();
                this._fireDepositExecutedEvent$1();
            }
            else {
                if (transactionState === 'Q') {
                    this.fetchAccountsDetails();
                }
            }
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetSettlementInstructionTransactionState exception ' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    _getDefaultPreferences$1: function AccountService_AccountService$_getDefaultPreferences$1() {
        return new AccountService.AccountPreferences(false, false, AccountService.AccountPreferences.dontSend, String.Empty, String.Empty, String.Empty, true, true, true, true, true);
    },
    
    _updateLocalPreferences$1: function AccountService_AccountService$_updateLocalPreferences$1(preferences) {
        if (!AccountService.AccountPreferences.equals(this._preferences$1, preferences)) {
            this._preferences$1 = preferences;
            this._fireAccountPreferencesChangedEvent$1();
        }
    },
    
    get_preferences: function AccountService_AccountService$get_preferences() {
        return this._preferences$1;
    },
    
    fetchPreferences: function AccountService_AccountService$fetchPreferences(successCallback, failureCallback) {
        AccountService.AccountService._log$1.debug('FetchPreferences');
        this._environment.invokeAsyncUsingJsonp(AccountService.AccountService._serviceName$1, 'GetPreferences', {}, Delegate.create(this, function(result) {
            if (result) {
                if (successCallback) {
                    successCallback.invoke(result);
                }
                this._updateLocalPreferences$1(result);
            }
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.debug('GetPreferences exception' + exception.message);
            if (failureCallback) {
                failureCallback.invoke(exception);
            }
            this._userService$1.handleSessionTimeout(exception);
        }), this.httpsMethods.contains('FetchPreferences'));
    },
    
    setPreferences: function AccountService_AccountService$setPreferences(successCallback, failureCallback, preferences) {
        AccountService.AccountService._log$1.debug(String.format('SetPreferences preferences=[{0}]', Framework.DictionaryUtil.dumpObjectToString(preferences)));
        if (!AccountService.AccountPreferences.equals(this._preferences$1, preferences)) {
            this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'SetPreferences', { accountPreferences: preferences }, Delegate.create(this, function(result) {
                successCallback.invoke(null);
                this._updateLocalPreferences$1(preferences);
            }), Delegate.create(this, function(exception) {
                AccountService.AccountService._log$1.debug('SetPreferences exception' + exception.message);
                this._updateLocalPreferences$1(preferences);
                failureCallback.invoke(exception);
                this._userService$1.handleSessionTimeout(exception);
            }));
        }
        else {
            successCallback.invoke(null);
        }
    },
    
    setDepositLimit: function AccountService_AccountService$setDepositLimit(successCallback, failureCallback, IDMMPeriodUnit, limit) {
        AccountService.AccountService._log$1.debug(String.format('SetDepositLimit IDMMPeriodUnit=[{0}] limit=[{1}]', IDMMPeriodUnit, limit));
        this._environment.invokeAsync(AccountService.AccountService._serviceName$1, 'SetDepositLimitOnPrimaryAccount', { IDMMPeriodUnit: IDMMPeriodUnit, limit: limit }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this.fetchAccountsDetails();
        }), Delegate.create(this, function(exception) {
            AccountService.AccountService._log$1.error('SetDepositLimit', exception);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    }
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.AccountDetails

AccountService.AccountDetails = function AccountService_AccountDetails() {
}
AccountService.AccountDetails.equals = function AccountService_AccountDetails$equals(details1, details2) {
    if (!details1 && !details2) {
        return true;
    }
    if (!details1 && details2) {
        return false;
    }
    if (details1 && !details2) {
        return false;
    }
    if (details1.CurrentBalance !== details2.CurrentBalance) {
        return false;
    }
    if (details1.TradingBalance !== details2.TradingBalance) {
        return false;
    }
    if (details1.LockedFunds !== details2.LockedFunds) {
        return false;
    }
    if (details1.WithdrawalBalance !== details2.WithdrawalBalance) {
        return false;
    }
    if (details1.IsTestAccount !== details2.IsTestAccount) {
        return false;
    }
    if (details1.CurrencyDecimalPlaces !== details2.CurrencyDecimalPlaces) {
        return false;
    }
    if (details1.CurrencyHtmlNotation !== details2.CurrencyHtmlNotation) {
        return false;
    }
    if (details1.CurrencyNotation !== details2.CurrencyNotation) {
        return false;
    }
    return true;
}
AccountService.AccountDetails.equalsArray = function AccountService_AccountDetails$equalsArray(details1, details2) {
    if (!details1 && !details2) {
        return true;
    }
    if (!details1 && details2) {
        return false;
    }
    if (details1 && !details2) {
        return false;
    }
    if (details1.length !== details2.length) {
        return false;
    }
    for (var i = 0; i < details1.length; i++) {
        if (!AccountService.AccountDetails.equals(details1[i], details2[i])) {
            return false;
        }
    }
    return true;
}
AccountService.AccountDetails.prototype = {
    AccountNumber: null,
    CurrentBalance: null,
    IDMMAccount: null,
    IDMMAccountClass: null,
    IDMMCurrency: null,
    LockedFunds: null,
    TradingBalance: null,
    WithdrawalBalance: null,
    IDMMPeriodUnitDeposit: null,
    DepositLimitInPeriod: null,
    PendingIDMMPeriodUnitDeposit: null,
    PendingDepositLimit: null,
    TSPendingLimitActivation: null,
    IsTestAccount: null,
    CurrencyHtmlNotation: null,
    CurrencyNotation: null,
    CurrencyDecimalPlaces: 0
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.RedirectBasedWalletRequestParameter

AccountService.RedirectBasedWalletRequestParameter = function AccountService_RedirectBasedWalletRequestParameter() {
}
AccountService.RedirectBasedWalletRequestParameter.prototype = {
    Name: null,
    Value: null
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.PaymentType

AccountService.PaymentType = function AccountService_PaymentType() {
}
AccountService.PaymentType.prototype = {
    AccountNumberCaption: null,
    AccountNumberLengthMax: 0,
    AccountNumberLengthMin: 0,
    AddressLineLength: 0,
    ClearingCodeLengthMax: 0,
    ClearingCodeLengthMin: 0,
    IDMMSIAmountRule_Payment: null,
    IDMMSIAmountRule_Receipt: null,
    IDMMSICardType: null,
    IDMMSICheckAlgorithm: null,
    IDMMSIClass: null,
    IDMMSIType: null,
    IDMMTXType_BankCharge: null,
    IDMMTXType_Payment: null,
    IDMMTXType_Receipt: null,
    IsBankChargeSeparate: false,
    IsBankNameNeeded: false,
    IsCvv2Needed: false,
    IsForPayments: false,
    IsForReceipts: false,
    IsInstant: false,
    IsNotificationNeeded: false,
    IsPinNeeded: false,
    IsRestricted: false,
    IsStartOfValidityNeeded: false,
    IsSwiftCodeNeeded: false,
    IsSwitchNumberNeeded: false,
    IsUrgentRequestPossible: false,
    Name: null,
    NoOfAddressLines: 0,
    OwnerNameLengthMax: 0,
    PinCaption: null
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.PaymentTransaction

AccountService.PaymentTransaction = function AccountService_PaymentTransaction() {
}
AccountService.PaymentTransaction.prototype = {
    IDMMSITransaction: null,
    IDMMSITXRequest: null,
    IDMMCustomer: null,
    IDMMAccount: null,
    ExtAdditionalData: null,
    IDMMSITransactionType: null,
    IDMMSIType: null,
    IDMMSITransactionState: null,
    Description: null,
    ExtReference: null,
    OrderedAmount: null,
    IsTransient: false,
    IsSuccess: false,
    ShouldRedirect: false,
    ExtTime: null,
    ExtAuthCode: null,
    ExtAccountNumber: null
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.PaymentInstrument

AccountService.PaymentInstrument = function AccountService_PaymentInstrument() {
}
AccountService.PaymentInstrument.prototype = {
    AccountOwner: null,
    Address: null,
    City: null,
    DisplayLabel: null,
    IDMMCountry: null,
    IDMMSIClass: null,
    IDMMSIInstruction: null,
    IDMMSIType: null,
    InactivityReason: null,
    IsActive: false,
    IsDefaultForPayments: false,
    IsDefaultForReceipts: false,
    IsForPayments: false,
    IsForReceipts: false,
    IsRedirectBasedWallet: false,
    IsSameAsMainAddress: false,
    IsUrgentByDefault: false,
    MMSITypeName: null,
    PaymentDailyLimit: null,
    PaymentTXLimit: null,
    Postcode: null,
    ReceiptDailyLimit: null,
    ReceiptTXLimit: null,
    State: null,
    VerificationStatus: 0,
    EndOfValidityYear: null,
    EndOfValidityMonth: null,
    StartOfValidityYear: null,
    StartOfValidityMonth: null,
    CardIssueNumber: null,
    IsCVV2Needed: false,
    MinWithdrawalAmount: null,
    MaxWithdrawalAmount: null,
    MinDepositAmount: null,
    MaxDepositAmount: null
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.RedirectBasedWalletRequest

AccountService.RedirectBasedWalletRequest = function AccountService_RedirectBasedWalletRequest() {
}
AccountService.RedirectBasedWalletRequest.prototype = {
    IsPost: false,
    Parameters: null,
    Url: null,
    UrlWithParameters: null
}


////////////////////////////////////////////////////////////////////////////////
// AccountService.SettlementInstructionTransactionStates

AccountService.SettlementInstructionTransactionStates = function AccountService_SettlementInstructionTransactionStates() {
}


AccountService.AccountPreferences.createClass('AccountService.AccountPreferences');
AccountService.AccountService.createClass('AccountService.AccountService', Framework.AbstractService, Framework.IPageWillChangeListener, UserService.IUserChangedListener);
AccountService.AccountDetails.createClass('AccountService.AccountDetails');
AccountService.RedirectBasedWalletRequestParameter.createClass('AccountService.RedirectBasedWalletRequestParameter');
AccountService.PaymentType.createClass('AccountService.PaymentType');
AccountService.PaymentTransaction.createClass('AccountService.PaymentTransaction');
AccountService.PaymentInstrument.createClass('AccountService.PaymentInstrument');
AccountService.RedirectBasedWalletRequest.createClass('AccountService.RedirectBasedWalletRequest');
AccountService.SettlementInstructionTransactionStates.createClass('AccountService.SettlementInstructionTransactionStates');
AccountService.AccountPreferences.plainText = 'PLAIN';
AccountService.AccountPreferences.html = 'HTML';
AccountService.AccountPreferences.dontSend = 'NOSEND';
AccountService.AccountPreferences.defaultType = null;
AccountService.AccountService._serviceName$1 = 'AccountService';
AccountService.AccountService._log$1 = Framework.Logger.getLog(AccountService.AccountService._serviceName$1);
AccountService.SettlementInstructionTransactionStates.enqueued = 'Q';
AccountService.SettlementInstructionTransactionStates.authorised = 'A';
AccountService.SettlementInstructionTransactionStates.cancelled = 'C';
AccountService.SettlementInstructionTransactionStates.sentToExecution = 'S';
AccountService.SettlementInstructionTransactionStates.executedSuccessfully = 'X';
AccountService.SettlementInstructionTransactionStates.failed = 'F';
AccountService.SettlementInstructionTransactionStates.inDoubt = 'D';
AccountService.SettlementInstructionTransactionStates.referral = 'R';
AccountService.SettlementInstructionTransactionStates.successfullyExecutedManually = 'M';
AccountService.SettlementInstructionTransactionStates.reconciledAsAuthorised = '+';
AccountService.SettlementInstructionTransactionStates.reconciledAsDeclined = '-';
AccountService.SettlementInstructionTransactionStates.referralRejectedByTheOperator = 'L';
AccountService.SettlementInstructionTransactionStates.referralConfirmedByTheOperator = 'O';
AccountService.SettlementInstructionTransactionStates.failedAfterReferral = 'J';
AccountService.SettlementInstructionTransactionStates.queryingTheOutcomeOfTheTransaction = '?';
AccountService.SettlementInstructionTransactionStates.waitingForThe2ndAuthorisation = '2';
AccountService.SettlementInstructionTransactionStates.referredBecauseRisky = 'Y';
AccountService.SettlementInstructionTransactionStates.successfulFundsNotReleased = 'H';
AccountService.SettlementInstructionTransactionStates.failedFundsNotReleased = 'E';
AccountService.SettlementInstructionTransactionStates.readyForNotification = 'W';
AccountService.SettlementInstructionTransactionStates.notificationInProgress = 'N';
AccountService.SettlementInstructionTransactionStates.readyForRedirection = 'W';
AccountService.SettlementInstructionTransactionStates.inRedirection = 'I';
AccountService.SettlementInstructionTransactionStates.verifying = 'V';
AccountService.SettlementInstructionTransactionStates.reversed = 'Z';

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('PlaytechService');

////////////////////////////////////////////////////////////////////////////////
// PlaytechService.IPlayerInfoChangedListener

PlaytechService.IPlayerInfoChangedListener = function() { };
PlaytechService.IPlayerInfoChangedListener.prototype = {
    onPlayerInfoChanged : null
}
PlaytechService.IPlayerInfoChangedListener.createInterface('PlaytechService.IPlayerInfoChangedListener');


////////////////////////////////////////////////////////////////////////////////
// PlaytechService.FundTransferResponse

PlaytechService.FundTransferResponse = function PlaytechService_FundTransferResponse() {
}
PlaytechService.FundTransferResponse.prototype = {
    Version: null,
    Status: null,
    TranId: null,
    Balance: null,
    BonusBalance: null,
    PostTransBalance: null,
    Currency: null,
    Error: null
}


////////////////////////////////////////////////////////////////////////////////
// PlaytechService.PlayerInfo

PlaytechService.PlayerInfo = function PlaytechService_PlayerInfo() {
}
PlaytechService.PlayerInfo.equals = function PlaytechService_PlayerInfo$equals(playerInfo1, playerInfo2) {
    if (!playerInfo1 && !playerInfo2) {
        return true;
    }
    if (!playerInfo1 && playerInfo2) {
        return false;
    }
    if (playerInfo1 && !playerInfo2) {
        return false;
    }
    if (playerInfo1.Version !== playerInfo2.Version) {
        return false;
    }
    if (playerInfo1.Error !== playerInfo2.Error) {
        return false;
    }
    if (playerInfo1.Status !== playerInfo2.Status) {
        return false;
    }
    if (playerInfo1.Client !== playerInfo2.Client) {
        return false;
    }
    if (playerInfo1.Balance !== playerInfo2.Balance) {
        return false;
    }
    if (playerInfo1.BonusBalance !== playerInfo2.BonusBalance) {
        return false;
    }
    if (playerInfo1.LastLoginDate !== playerInfo2.LastLoginDate) {
        return false;
    }
    if (playerInfo1.TotalDeposits !== playerInfo2.TotalDeposits) {
        return false;
    }
    if (playerInfo1.FundTransferDeposits !== playerInfo2.FundTransferDeposits) {
        return false;
    }
    if (playerInfo1.DeclinedWDBonuses !== playerInfo2.DeclinedWDBonuses) {
        return false;
    }
    if (playerInfo1.Frozen !== playerInfo2.Frozen) {
        return false;
    }
    if (playerInfo1.VipLevel !== playerInfo2.VipLevel) {
        return false;
    }
    if (playerInfo1.CompPointsBalance !== playerInfo2.CompPointsBalance) {
        return false;
    }
    if (playerInfo1.HeldFundsAmount !== playerInfo2.HeldFundsAmount) {
        return false;
    }
    if (playerInfo1.CurrentBet !== playerInfo2.CurrentBet) {
        return false;
    }
    return true;
}
PlaytechService.PlayerInfo.prototype = {
    Version: null,
    Error: null,
    Status: null,
    Client: null,
    Balance: null,
    BonusBalance: null,
    LastLoginDate: null,
    TotalDeposits: null,
    FundTransferDeposits: null,
    DeclinedWDBonuses: null,
    Frozen: null,
    VipLevel: null,
    CompPointsBalance: null,
    HeldFundsAmount: null,
    CurrentBet: null
}


////////////////////////////////////////////////////////////////////////////////
// PlaytechService.PlaytechService

PlaytechService.PlaytechService = function PlaytechService_PlaytechService() {
    this._playerInfoChangedListeners$1 = new Framework.ListenerInvoker(true);
    PlaytechService.PlaytechService.constructBase(this);
    PlaytechService.PlaytechService._log$1.debug('ctor');
}
PlaytechService.PlaytechService.prototype = {
    _advertiser: null,
    _profileId: null,
    
    init: function PlaytechService_PlaytechService$init(environment, parameters) {
        PlaytechService.PlaytechService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        PlaytechService.PlaytechService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(PlaytechService.PlaytechService._serviceName$1);
        if (state) {
            this._setState$1(state);
        }
    },
    
    start: function PlaytechService_PlaytechService$start() {
        PlaytechService.PlaytechService._log$1.debug('Start');
        var memberQueryStringName = 'member';
        var profileQueryStringName = 'profile';
        var cookieValue = Framework.CookieUtil.getCookie('_defaultAspxQuerystring');
        if (!String.isNullOrEmpty(cookieValue)) {
            var regex = new RegExp('(?:^|&)' + memberQueryStringName + '=(.*?)&');
            var cookieParse = regex.exec(cookieValue + '&');
            if (cookieParse && cookieParse.length === 2) {
                this._advertiser = cookieParse[1];
            }
            regex = new RegExp('(?:^|&)' + profileQueryStringName + '=(.*?)&');
            cookieParse = regex.exec(cookieValue + '&');
            if (cookieParse && cookieParse.length === 2) {
                this._profileId = cookieParse[1];
            }
            if (!String.isNullOrEmpty(this._advertiser) && !String.isNullOrEmpty(this._profileId)) {
                Framework.CookieUtil.setCookie('banner_domainclick', this._advertiser + ',_,' + this._profileId + ',_');
            }
        }
    },
    
    onPageWillChange: function PlaytechService_PlaytechService$onPageWillChange() {
        this._environment.storeState(PlaytechService.PlaytechService._serviceName$1, this._getState$1());
    },
    
    _userService$1: null,
    
    setUserService: function PlaytechService_PlaytechService$setUserService(userService) {
        PlaytechService.PlaytechService._log$1.debug('SetUserService');
        this._userService$1 = userService;
    },
    
    onUserChanged: function PlaytechService_PlaytechService$onUserChanged(eventSource) {
        PlaytechService.PlaytechService._log$1.debug('OnUserChanged');
        if (this._userService$1.isLoggedIn()) {
            this.fetchPlayerInfo();
        }
        else if (this._playerInfo$1) {
            this._playerInfo$1 = null;
            this._firePlayerInfoChangedEvent$1();
        }
    },
    
    onPreRegisterCustomer: function PlaytechService_PlaytechService$onPreRegisterCustomer(eventSource) {
        this._userService$1.setIntegrationDetails('Playtech', 'Advertiser', this._advertiser);
        this._userService$1.setIntegrationDetails('Playtech', 'ProfileId', this._profileId);
    },
    
    registerPlayerInfoChangedListener: function PlaytechService_PlaytechService$registerPlayerInfoChangedListener(playerInfoChangedListener) {
        PlaytechService.PlaytechService._log$1.debug('RegisterPlayerInfoChangedListener');
        this._playerInfoChangedListeners$1.registerListener(playerInfoChangedListener);
    },
    
    _firePlayerInfoChangedEvent$1: function PlaytechService_PlaytechService$_firePlayerInfoChangedEvent$1() {
        PlaytechService.PlaytechService._log$1.debug('FirePlayerInfoChangedEvent');
        this._playerInfoChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onPlayerInfoChanged(this);
        }));
    },
    
    _getState$1: function PlaytechService_PlaytechService$_getState$1() {
        return { playerInfo: this._playerInfo$1 };
    },
    
    _setState$1: function PlaytechService_PlaytechService$_setState$1(state) {
        this._playerInfo$1 = state['playerInfo'];
    },
    
    _playerInfo$1: null,
    
    get_playerInfo: function PlaytechService_PlaytechService$get_playerInfo() {
        return this._playerInfo$1;
    },
    
    fetchPlayerInfo: function PlaytechService_PlaytechService$fetchPlayerInfo() {
        PlaytechService.PlaytechService._log$1.debug('GetPlayerInfo');
        this._environment.invokeAsync(PlaytechService.PlaytechService._serviceName$1, 'GetPlayerInfo', {}, Delegate.create(this, function(result) {
            var hasChanged = !PlaytechService.PlayerInfo.equals(this._playerInfo$1, result);
            if (hasChanged) {
                this._playerInfo$1 = result;
                this._firePlayerInfoChangedEvent$1();
            }
        }), Delegate.create(this, function(exception) {
            if (this._playerInfo$1) {
                this._playerInfo$1 = null;
                this._firePlayerInfoChangedEvent$1();
            }
        }));
    },
    
    fundTransfer: function PlaytechService_PlaytechService$fundTransfer(successCallback, failureCallback, amount, comments, IDMMCurrency, isDepositToPlaytech, password) {
        PlaytechService.PlaytechService._log$1.debug('FundTransfer');
        this._environment.invokeAsync(PlaytechService.PlaytechService._serviceName$1, 'FundTransfer', { amount: amount, comments: comments, idmmCurrency: IDMMCurrency, isDepositToPlaytech: isDepositToPlaytech, password: password }, Delegate.create(this, function(result) {
            successCallback.invoke(result);
            this.fetchPlayerInfo();
        }), Delegate.create(this, function(exception) {
            failureCallback.invoke(exception);
        }));
    },
    
    setupRBWFundTransfer: function PlaytechService_PlaytechService$setupRBWFundTransfer(password) {
        PlaytechService.PlaytechService._log$1.debug('SetupRBWFundTransfer');
        this._environment.invoke(PlaytechService.PlaytechService._serviceName$1, 'SetupRBWFundTransfer', { password: password });
    }
}


PlaytechService.FundTransferResponse.createClass('PlaytechService.FundTransferResponse');
PlaytechService.PlayerInfo.createClass('PlaytechService.PlayerInfo');
PlaytechService.PlaytechService.createClass('PlaytechService.PlaytechService', Framework.AbstractService, Framework.IPageWillChangeListener, UserService.IUserChangedListener, UserService.IPreRegisterCustomerListener);
PlaytechService.PlaytechService._serviceName$1 = 'PlaytechService';
PlaytechService.PlaytechService._log$1 = Framework.Logger.getLog(PlaytechService.PlaytechService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('FixedOddsBettingService');

////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.IBetPlacementStateChangedListener

FixedOddsBettingService.IBetPlacementStateChangedListener = function() { };
FixedOddsBettingService.IBetPlacementStateChangedListener.prototype = {
    onBetPlacementStateChanged : null
}
FixedOddsBettingService.IBetPlacementStateChangedListener.createInterface('FixedOddsBettingService.IBetPlacementStateChangedListener');


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.IBettingPreferencesChangedListener

FixedOddsBettingService.IBettingPreferencesChangedListener = function() { };
FixedOddsBettingService.IBettingPreferencesChangedListener.prototype = {
    onBettingPreferencesChanged : null
}
FixedOddsBettingService.IBettingPreferencesChangedListener.createInterface('FixedOddsBettingService.IBettingPreferencesChangedListener');


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.OverrideToShowConfirmation

FixedOddsBettingService.OverrideToShowConfirmation = function() { };
FixedOddsBettingService.OverrideToShowConfirmation.prototype = {
    overrideToShowConfirmation: 1, 
    overrideToNotShowConfirmation: 2, 
    notOverride: 3
}
FixedOddsBettingService.OverrideToShowConfirmation.createEnum('FixedOddsBettingService.OverrideToShowConfirmation', false);


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.IOddsTypeChangedListener

FixedOddsBettingService.IOddsTypeChangedListener = function() { };
FixedOddsBettingService.IOddsTypeChangedListener.prototype = {
    onOddsTypeChanged : null
}
FixedOddsBettingService.IOddsTypeChangedListener.createInterface('FixedOddsBettingService.IOddsTypeChangedListener');


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetPlacementState

FixedOddsBettingService.BetPlacementState = function FixedOddsBettingService_BetPlacementState() {
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetTerminatedState

FixedOddsBettingService.BetTerminatedState = function FixedOddsBettingService_BetTerminatedState() {
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.CalculatedBet

FixedOddsBettingService.CalculatedBet = function FixedOddsBettingService_CalculatedBet(potentialReturn, totalStake, unitCount, IDFOBetType) {
    this.PotentialReturn = potentialReturn;
    this.TotalStake = totalStake;
    this.UnitCount = unitCount;
    this.IDFOBetType = IDFOBetType;
}
FixedOddsBettingService.CalculatedBet.equals = function FixedOddsBettingService_CalculatedBet$equals(calculatedBet1, calculatedBet2) {
    if (!calculatedBet1) {
        return !calculatedBet2;
    }
    else if (!calculatedBet2) {
        return false;
    }
    if (calculatedBet1.PotentialReturn !== calculatedBet2.PotentialReturn) {
        return false;
    }
    if (calculatedBet1.TotalStake !== calculatedBet2.TotalStake) {
        return false;
    }
    if (calculatedBet1.IDFOBetType !== calculatedBet2.IDFOBetType) {
        return false;
    }
    if (calculatedBet1.UnitCount !== calculatedBet2.UnitCount) {
        return false;
    }
    return true;
}
FixedOddsBettingService.CalculatedBet.prototype = {
    PotentialReturn: null,
    TotalStake: null,
    UnitCount: 0,
    IDFOBetType: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetInbound

FixedOddsBettingService.BetInbound = function FixedOddsBettingService_BetInbound(betLegs, IDFOBetType, betTypeName, IDFOMultiRacePool, isPool, winStake, placeStake, showStake) {
    this.BetLegs = [];
    this.BetLegs = betLegs;
    this.IDFOBetType = IDFOBetType;
    this.BetTypeName = betTypeName;
    this.IDFOMultiRacePool = IDFOMultiRacePool;
    this.IsPool = isPool;
    this.WinStake = winStake;
    this.PlaceStake = placeStake;
    this.ShowStake = showStake;
}
FixedOddsBettingService.BetInbound.prototype = {
    IDFOBetType: null,
    BetTypeName: null,
    IDFOMultiRacePool: null,
    IsPool: false,
    WinStake: null,
    PlaceStake: null,
    ShowStake: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetLeg

FixedOddsBettingService.BetLeg = function FixedOddsBettingService_BetLeg(handicap, upperBand, lowerBand, IDFOPriceType, IDFOSelection, priceDown, priceUp, eachWayReduction, eachWayPlaceTerms, isTrap, systemTag, interrelationTag, IDFOEventScorecast) {
    this.Handicap = handicap;
    this.UpperBand = upperBand;
    this.LowerBand = lowerBand;
    this.IDFOPriceType = IDFOPriceType;
    this.IDFOSelection = IDFOSelection;
    this.PriceDown = priceDown;
    this.PriceUp = priceUp;
    this.EachWayReduction = eachWayReduction;
    this.EachWayPlaceTerms = eachWayPlaceTerms;
    this.IsTrap = isTrap;
    this.SystemTag = systemTag;
    this.InterrelationTag = interrelationTag;
    this.IDFOEventScorecast = IDFOEventScorecast;
}
FixedOddsBettingService.BetLeg.createFromSelection = function FixedOddsBettingService_BetLeg$createFromSelection(selection, systemTag, interrelationTag) {
    return new FixedOddsBettingService.BetLeg(selection.Handicap, selection.UpperBand, selection.LowerBand, selection.IDFOPriceType[selection.ActivePriceType], selection.IDFOSelection, selection.PriceDown, selection.PriceUp, selection.EachWayReduction[selection.ActiveEachWay], selection.EachWayPlaceTerms[selection.ActiveEachWay], selection.IsTrap, systemTag, interrelationTag, selection.IDFOEventScorecast);
}
FixedOddsBettingService.BetLeg.create = function FixedOddsBettingService_BetLeg$create(betLeg) {
    return new FixedOddsBettingService.BetLeg(betLeg.Handicap, betLeg.UpperBand, betLeg.LowerBand, betLeg.IDFOPriceType, betLeg.IDFOSelection, betLeg.PriceDown, betLeg.PriceUp, betLeg.EachWayReduction, betLeg.EachWayPlaceTerms, betLeg.IsTrap, betLeg.SystemTag, betLeg.InterrelationTag, betLeg.IDFOEventScorecast);
}
FixedOddsBettingService.BetLeg.prototype = {
    Handicap: null,
    UpperBand: null,
    LowerBand: null,
    IDFOPriceType: null,
    IDFOSelection: null,
    PriceDown: null,
    PriceUp: null,
    EachWayReduction: null,
    EachWayPlaceTerms: null,
    IsTrap: false,
    SystemTag: null,
    InterrelationTag: null,
    IDFOEventScorecast: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetSlipInbound

FixedOddsBettingService.BetSlipInbound = function FixedOddsBettingService_BetSlipInbound(isFree, bets) {
    this.Bets = [];
    this.IsFree = isFree;
    this.Bets = bets;
}
FixedOddsBettingService.BetSlipInbound.prototype = {
    IsFree: false
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetSlipOutbound

FixedOddsBettingService.BetSlipOutbound = function FixedOddsBettingService_BetSlipOutbound() {
}
FixedOddsBettingService.BetSlipOutbound.prototype = {
    Bets: null,
    IsFree: false,
    IDFOBetSlip: null,
    ExternalReference: null,
    Status: null,
    TopupAmount: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetOutbound

FixedOddsBettingService.BetOutbound = function FixedOddsBettingService_BetOutbound() {
    this.BetLegs = [];
}
FixedOddsBettingService.BetOutbound.prototype = {
    IDFOBetType: null,
    IDFOMultiRacePool: null,
    IsPool: false,
    WinStake: null,
    PlaceStake: null,
    ShowStake: null,
    ExternalReference: null,
    MaxTakeout: null,
    PotentialReturn: null,
    TotalStake: null,
    UnitCount: 0
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetType

FixedOddsBettingService.BetType = function FixedOddsBettingService_BetType() {
}
FixedOddsBettingService.BetType.prototype = {
    IDFOBetType: null,
    Name: null,
    IsEachWayAllowed: false
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetSlipStatus

FixedOddsBettingService.BetSlipStatus = function FixedOddsBettingService_BetSlipStatus() {
}
FixedOddsBettingService.BetSlipStatus.isConfirmationRequired = function FixedOddsBettingService_BetSlipStatus$isConfirmationRequired(betSlipStatus) {
    return betSlipStatus.State === 1;
}
FixedOddsBettingService.BetSlipStatus.isPreProcess = function FixedOddsBettingService_BetSlipStatus$isPreProcess(betSlipStatus) {
    return !betSlipStatus.DetailedState;
}
FixedOddsBettingService.BetSlipStatus.isAccepted = function FixedOddsBettingService_BetSlipStatus$isAccepted(betSlipStatus) {
    return betSlipStatus.State === 2;
}
FixedOddsBettingService.BetSlipStatus.isAcceptable = function FixedOddsBettingService_BetSlipStatus$isAcceptable(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.acceptable);
}
FixedOddsBettingService.BetSlipStatus.isRejected = function FixedOddsBettingService_BetSlipStatus$isRejected(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.rejected);
}
FixedOddsBettingService.BetSlipStatus.isPriceChanged = function FixedOddsBettingService_BetSlipStatus$isPriceChanged(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.priceChanged);
}
FixedOddsBettingService.BetSlipStatus.isHandicapChanged = function FixedOddsBettingService_BetSlipStatus$isHandicapChanged(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.handicapChanged);
}
FixedOddsBettingService.BetSlipStatus.isBandChanged = function FixedOddsBettingService_BetSlipStatus$isBandChanged(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.bandChanged);
}
FixedOddsBettingService.BetSlipStatus.isReoffered = function FixedOddsBettingService_BetSlipStatus$isReoffered(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.reoffered);
}
FixedOddsBettingService.BetSlipStatus.isReofferTimeout = function FixedOddsBettingService_BetSlipStatus$isReofferTimeout(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.reofferTimeout);
}
FixedOddsBettingService.BetSlipStatus.isTopupRequired = function FixedOddsBettingService_BetSlipStatus$isTopupRequired(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.topupRequired);
}
FixedOddsBettingService.BetSlipStatus.isMaxTakeoutViolation = function FixedOddsBettingService_BetSlipStatus$isMaxTakeoutViolation(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.maxTakeoutViolation);
}
FixedOddsBettingService.BetSlipStatus.isWaiting = function FixedOddsBettingService_BetSlipStatus$isWaiting(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.waiting);
}
FixedOddsBettingService.BetSlipStatus.isEachWayChanged = function FixedOddsBettingService_BetSlipStatus$isEachWayChanged(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.eachWayChanged);
}
FixedOddsBettingService.BetSlipStatus.isAbortProcessing = function FixedOddsBettingService_BetSlipStatus$isAbortProcessing(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.abortProcessing);
}
FixedOddsBettingService.BetSlipStatus.isSecurityCodeRequiredForTopup = function FixedOddsBettingService_BetSlipStatus$isSecurityCodeRequiredForTopup(betSlipStatus) {
    return (betSlipStatus.DetailedState & FixedOddsBettingService.BetSlipStatus.securityCodeRequiredForTopup);
}
FixedOddsBettingService.BetSlipStatus.prototype = {
    State: 0,
    DetailedState: 0,
    StatusCode: null,
    StatusText: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.BetTypesAndReturns

FixedOddsBettingService.BetTypesAndReturns = function FixedOddsBettingService_BetTypesAndReturns() {
    this.AllowedBetTypes = [];
    this.PotentialReturns = new FixedOddsBettingService.PotentialReturn();
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.PotentialReturn

FixedOddsBettingService.PotentialReturn = function FixedOddsBettingService_PotentialReturn() {
    this.PerBetType = {};
    this.PerSelection = {};
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.PriceType

FixedOddsBettingService.PriceType = function FixedOddsBettingService_PriceType() {
}
FixedOddsBettingService.PriceType.getValidPriceTypesForSingle = function FixedOddsBettingService_PriceType$getValidPriceTypesForSingle() {
    return FixedOddsBettingService.PriceType._validPriceTypesForSingle;
}
FixedOddsBettingService.PriceType.isValidForSingle = function FixedOddsBettingService_PriceType$isValidForSingle(IDFOPriceType) {
    return FixedOddsBettingService.PriceType._validPriceTypesForSingle.contains(IDFOPriceType);
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.FixedOddsBettingPreferences

FixedOddsBettingService.FixedOddsBettingPreferences = function FixedOddsBettingService_FixedOddsBettingPreferences(oddsType, isBetConfirmationScreenShownBeforePlacement, isBetConfirmationScreenShownAfterPlacement, isReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted) {
    this.OddsType = oddsType;
    this.IsBetConfirmationScreenShownBeforePlacement = isBetConfirmationScreenShownBeforePlacement;
    this.IsBetConfirmationScreenShownAfterPlacement = isBetConfirmationScreenShownAfterPlacement;
    this.IsReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted = isReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted;
}
FixedOddsBettingService.FixedOddsBettingPreferences.equals = function FixedOddsBettingService_FixedOddsBettingPreferences$equals(preferences1, preferences2) {
    if (!preferences1 && !preferences2) {
        return true;
    }
    if (!preferences1 && preferences2) {
        return false;
    }
    if (preferences1 && !preferences2) {
        return false;
    }
    if (!String.equals(preferences1.OddsType, preferences2.OddsType, true)) {
        return false;
    }
    if (preferences1.IsBetConfirmationScreenShownBeforePlacement !== preferences2.IsBetConfirmationScreenShownBeforePlacement) {
        return false;
    }
    if (preferences1.IsBetConfirmationScreenShownAfterPlacement !== preferences2.IsBetConfirmationScreenShownAfterPlacement) {
        return false;
    }
    if (preferences1.IsReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted !== preferences2.IsReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted) {
        return false;
    }
    if (preferences1.BetGracePeriod !== preferences2.BetGracePeriod) {
        return false;
    }
    return true;
}
FixedOddsBettingService.FixedOddsBettingPreferences.isOddsTypeValid = function FixedOddsBettingService_FixedOddsBettingPreferences$isOddsTypeValid(oddsType) {
    if (String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.american, oddsType, true) || String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.decimals, oddsType, true) || String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.fractions, oddsType, true)) {
        return true;
    }
    return false;
}
FixedOddsBettingService.FixedOddsBettingPreferences.prototype = {
    OddsType: null,
    IsBetConfirmationScreenShownBeforePlacement: false,
    IsBetConfirmationScreenShownAfterPlacement: false,
    IsReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted: false,
    BetGracePeriod: null
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.FixedOddsBettingService

FixedOddsBettingService.FixedOddsBettingService = function FixedOddsBettingService_FixedOddsBettingService() {
    this._areasWhereBetPlacementStays$1 = [ 'betting' ];
    this._betPlacementStateChangedListeners$1 = new Framework.ListenerInvoker(false);
    this._oddsTypeChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._bettingPreferencesChangedListeners$1 = new Framework.ListenerInvoker(true);
    FixedOddsBettingService.FixedOddsBettingService.constructBase(this);
    FixedOddsBettingService.FixedOddsBettingService._log$1.debug('ctor');
}
FixedOddsBettingService.FixedOddsBettingService.adjustBetSlipCalculationsForFreeBet = function FixedOddsBettingService_FixedOddsBettingService$adjustBetSlipCalculationsForFreeBet(betSlipCalculation, isFree) {
    FixedOddsBettingService.FixedOddsBettingService._log$1.debug('AdjustBetSlipCalculationsForFreeBet');
    if (isFree) {
        FixedOddsBettingService.FixedOddsBettingService._adjustCalculatedBetDictionary$1(betSlipCalculation.PerSelection);
        FixedOddsBettingService.FixedOddsBettingService._adjustCalculatedBetDictionary$1(betSlipCalculation.PerBetType);
    }
    return betSlipCalculation;
}
FixedOddsBettingService.FixedOddsBettingService._adjustCalculatedBetDictionary$1 = function FixedOddsBettingService_FixedOddsBettingService$_adjustCalculatedBetDictionary$1(calculatedBets) {
    var $dict1 = calculatedBets;
    for (var $key2 in $dict1) {
        var entry = { key: $key2, value: $dict1[$key2] };
        var calculation = entry.value;
        if (calculation.PotentialReturn > 0) {
            calculation.PotentialReturn -= calculation.TotalStake;
        }
    }
}
FixedOddsBettingService.FixedOddsBettingService._adjustBetSlipOutboundForFreeBet$1 = function FixedOddsBettingService_FixedOddsBettingService$_adjustBetSlipOutboundForFreeBet$1(betSlipOutbound, isFree) {
    FixedOddsBettingService.FixedOddsBettingService._log$1.debug('AdjustBetSlipOutboundForFreeBet');
    if (isFree) {
        for (var i = 0; i < betSlipOutbound.Bets.length; i++) {
            betSlipOutbound.Bets[i].PotentialReturn -= betSlipOutbound.Bets[i].WinStake + (betSlipOutbound.Bets[i].PlaceStake || 0);
        }
    }
    return betSlipOutbound;
}
FixedOddsBettingService.FixedOddsBettingService._getSimpleSelectionKey$1 = function FixedOddsBettingService_FixedOddsBettingService$_getSimpleSelectionKey$1(IDFOSelection) {
    return IDFOSelection.toString();
}
FixedOddsBettingService.FixedOddsBettingService._getScorecastSelectionKey$1 = function FixedOddsBettingService_FixedOddsBettingService$_getScorecastSelectionKey$1(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
    return String.format('{0}-{1}-{2}', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
}
FixedOddsBettingService.FixedOddsBettingService._getSelectionKey$1 = function FixedOddsBettingService_FixedOddsBettingService$_getSelectionKey$1(selection) {
    return (!selection.IDFOEventScorecast) ? FixedOddsBettingService.FixedOddsBettingService._getSimpleSelectionKey$1(selection.IDFOSelection) : FixedOddsBettingService.FixedOddsBettingService._getScorecastSelectionKey$1(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS);
}
FixedOddsBettingService.FixedOddsBettingService.prototype = {
    _isBetConfirmationScreenShownBeforePlacementOverride$1: 0,
    _isSecondConfirmation$1: false,
    _selections$1: null,
    
    get_selections: function FixedOddsBettingService_FixedOddsBettingService$get_selections() {
        return this._selections$1;
    },
    
    _betSlipCalculation$1: null,
    
    get_betSlipCalculation: function FixedOddsBettingService_FixedOddsBettingService$get_betSlipCalculation() {
        return this._betSlipCalculation$1;
    },
    
    _betSlipInbound$1: null,
    
    get_betSlip: function FixedOddsBettingService_FixedOddsBettingService$get_betSlip() {
        return this._betSlipInbound$1;
    },
    
    _betSlipOutbound$1: null,
    
    get_betSlipOutbound: function FixedOddsBettingService_FixedOddsBettingService$get_betSlipOutbound() {
        return this._betSlipOutbound$1;
    },
    
    _betPlacementState$1: 0,
    
    get_betPlacementState: function FixedOddsBettingService_FixedOddsBettingService$get_betPlacementState() {
        return this._betPlacementState$1;
    },
    
    _betTerminatedState$1: 0,
    
    get_betTerminatedState: function FixedOddsBettingService_FixedOddsBettingService$get_betTerminatedState() {
        return this._betTerminatedState$1;
    },
    
    _gracePeriodRemaining$1: null,
    
    get_gracePeriodRemaining: function FixedOddsBettingService_FixedOddsBettingService$get_gracePeriodRemaining() {
        return this._gracePeriodRemaining$1 || 0;
    },
    
    decreaseGracePeriodRemaining: function FixedOddsBettingService_FixedOddsBettingService$decreaseGracePeriodRemaining() {
        this._gracePeriodRemaining$1--;
    },
    
    _getState$1: function FixedOddsBettingService_FixedOddsBettingService$_getState$1() {
        return { preferences: this._preferences$1, selections: this._selections$1, betSlipCalculation: this._betSlipCalculation$1, betSlipInbound: this._betSlipInbound$1, betSlipOutbound: this._betSlipOutbound$1, betPlacementState: this._betPlacementState$1, betTerminatedState: this._betTerminatedState$1, isSecondConfirmation: this._isSecondConfirmation$1, gracePeriodRemaining: this._gracePeriodRemaining$1, isBetConfirmationScreenShownBeforePlacementOverride: this._isBetConfirmationScreenShownBeforePlacementOverride$1 };
    },
    
    _setState$1: function FixedOddsBettingService_FixedOddsBettingService$_setState$1(state) {
        this._preferences$1 = state['preferences'];
        this._selections$1 = state['selections'];
        this._betSlipCalculation$1 = state['betSlipCalculation'];
        this._betSlipInbound$1 = state['betSlipInbound'];
        this._betSlipOutbound$1 = state['betSlipOutbound'];
        this._betPlacementState$1 = state['betPlacementState'];
        this._betTerminatedState$1 = state['betTerminatedState'];
        this._isSecondConfirmation$1 = state['isSecondConfirmation'];
        this._gracePeriodRemaining$1 = state['gracePeriodRemaining'];
        this._isBetConfirmationScreenShownBeforePlacementOverride$1 = state['isBetConfirmationScreenShownBeforePlacementOverride'];
    },
    
    _updateBetPlacementState$1: function FixedOddsBettingService_FixedOddsBettingService$_updateBetPlacementState$1(betPlacementState, fireBetPlacementStateChangedEventUnconditionally, betTerminatedState) {
        this._betTerminatedState$1 = (betPlacementState === FixedOddsBettingService.BetPlacementState.rejected && betTerminatedState === FixedOddsBettingService.BetTerminatedState.notApplicableState) ? ((String.isNullOrEmpty(this._betSlipOutbound$1.Status.StatusText)) ? FixedOddsBettingService.BetTerminatedState.generalRejection : FixedOddsBettingService.BetTerminatedState.displayStatusRejection) : betTerminatedState;
        if (this._betPlacementState$1 !== betPlacementState) {
            this._betPlacementState$1 = betPlacementState;
            this._fireBetPlacementStateChangedEvent$1(this._betPlacementState$1);
        }
        else if (fireBetPlacementStateChangedEventUnconditionally) {
            this._fireBetPlacementStateChangedEvent$1(this._betPlacementState$1);
        }
    },
    
    _checkIfBetRejectedButStillValid$1: function FixedOddsBettingService_FixedOddsBettingService$_checkIfBetRejectedButStillValid$1() {
        if (this._betSlipOutbound$1.Status.State === FixedOddsBettingService.BetPlacementState.rejected && !FixedOddsBettingService.BetSlipStatus.isAbortProcessing(this._betSlipOutbound$1.Status) && !FixedOddsBettingService.BetSlipStatus.isMaxTakeoutViolation(this._betSlipOutbound$1.Status) && !FixedOddsBettingService.BetSlipStatus.isReofferTimeout(this._betSlipOutbound$1.Status) && this._betSlipOutbound$1.Status.DetailedState !== FixedOddsBettingService.BetSlipStatus.rejected) {
            return true;
        }
        return false;
    },
    
    _adjustBetSlipCalculation$1: function FixedOddsBettingService_FixedOddsBettingService$_adjustBetSlipCalculation$1() {
        for (var i = 0; i < this._betSlipOutbound$1.Bets.length; i++) {
            this._betSlipCalculation$1[i].TotalStake = this._betSlipOutbound$1.Bets[i].TotalStake;
            this._betSlipCalculation$1[i].PotentialReturn = this._betSlipOutbound$1.Bets[i].PotentialReturn;
        }
    },
    
    _adjustBetSlipInbound$1: function FixedOddsBettingService_FixedOddsBettingService$_adjustBetSlipInbound$1() {
        for (var i = 0; i < this._betSlipOutbound$1.Bets.length; i++) {
            this._betSlipInbound$1.Bets[i].PlaceStake = this._betSlipOutbound$1.Bets[i].PlaceStake;
            this._betSlipInbound$1.Bets[i].WinStake = this._betSlipOutbound$1.Bets[i].WinStake;
            this._betSlipInbound$1.Bets[i].ShowStake = this._betSlipOutbound$1.Bets[i].ShowStake;
            for (var j = 0; j < this._betSlipOutbound$1.Bets[i].BetLegs.length; j++) {
                if (!this._betSlipInbound$1.Bets[i].BetLegs[j].IDFOEventScorecast) {
                    var selection = this._selections$1[FixedOddsBettingService.FixedOddsBettingService._getSimpleSelectionKey$1(this._betSlipInbound$1.Bets[i].BetLegs[j].IDFOSelection)];
                    if (this._betSlipInbound$1.Bets[i].BetLegs[j].UpperBand !== this._betSlipOutbound$1.Bets[i].BetLegs[j].UpperBand) {
                        selection.SelectionName = selection.SelectionName.replace(this._betSlipInbound$1.Bets[i].BetLegs[j].UpperBand.toString(), this._betSlipOutbound$1.Bets[i].BetLegs[j].UpperBand.toString());
                    }
                    if (this._betSlipInbound$1.Bets[i].BetLegs[j].LowerBand !== this._betSlipOutbound$1.Bets[i].BetLegs[j].LowerBand) {
                        selection.SelectionName = selection.SelectionName.replace(this._betSlipInbound$1.Bets[i].BetLegs[j].LowerBand.toString(), this._betSlipOutbound$1.Bets[i].BetLegs[j].LowerBand.toString());
                    }
                }
                var betLeg = FixedOddsBettingService.BetLeg.create(this._betSlipOutbound$1.Bets[i].BetLegs[j]);
                this._betSlipInbound$1.Bets[i].BetLegs[j] = betLeg;
            }
        }
    },
    
    onPageWillChange: function FixedOddsBettingService_FixedOddsBettingService$onPageWillChange() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('OnPageWillChange');
        this._environment.storeState(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, this._getState$1());
    },
    
    _accountService$1: null,
    
    setAccountService: function FixedOddsBettingService_FixedOddsBettingService$setAccountService(accountService) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('SetAccountService');
        this._accountService$1 = accountService;
    },
    
    _navigationService$1: null,
    
    setNavigationService: function FixedOddsBettingService_FixedOddsBettingService$setNavigationService(navigationService) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('SetNavigationService');
        this._navigationService$1 = navigationService;
    },
    
    _userService$1: null,
    
    setUserService: function FixedOddsBettingService_FixedOddsBettingService$setUserService(userService) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('SetUserService');
        this._userService$1 = userService;
        this._userService$1.registerUserChangedListener(this);
    },
    
    onUserChanged: function FixedOddsBettingService_FixedOddsBettingService$onUserChanged(eventSource) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('OnUserChanged');
        if (this._userService$1.isLoggedIn()) {
            this.fetchPreferences();
        }
    },
    
    init: function FixedOddsBettingService_FixedOddsBettingService$init(environment, parameters) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        FixedOddsBettingService.FixedOddsBettingService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(FixedOddsBettingService.FixedOddsBettingService._serviceName$1);
        if (state) {
            this._setState$1(state);
        }
        else {
            var oddsType = FixedOddsBettingService.FixedOddsBettingPreferences.fractions;
            var isBetConfirmationScreenShownBeforePlacement = true;
            var isBetConfirmationScreenShownAfterPlacement = true;
            var isReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted = false;
            if (!String.isNullOrEmpty(parameters['default-odds-type'])) {
                oddsType = parameters['default-odds-type'];
            }
            if (!String.isNullOrEmpty(parameters['is-bet-confirmation-screen-shown-before-placement'])) {
                isBetConfirmationScreenShownBeforePlacement = Boolean.parse(parameters['is-bet-confirmation-screen-shown-before-placement']);
            }
            if (!String.isNullOrEmpty(parameters['is-bet-confirmation-screen-shown-after-placement'])) {
                isBetConfirmationScreenShownAfterPlacement = Boolean.parse(parameters['is-bet-confirmation-screen-shown-after-placement']);
            }
            if (!String.isNullOrEmpty(parameters['is-reoffer-for-bets-with-in-running-selections-automatically-accepted'])) {
                isReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted = Boolean.parse(parameters['is-reoffer-for-bets-with-in-running-selections-automatically-accepted']);
            }
            this._preferences$1 = new FixedOddsBettingService.FixedOddsBettingPreferences(oddsType, isBetConfirmationScreenShownBeforePlacement, isBetConfirmationScreenShownAfterPlacement, isReOfferForBetsWithInRunningSelectionsAutomaticallyAccepted);
            this._gracePeriodRemaining$1 = 0;
        }
        if (!String.isNullOrEmpty(parameters['areas-where-bet-placement-stays'])) {
            this._areasWhereBetPlacementStays$1 = parameters['areas-where-bet-placement-stays'].toString().toLowerCase().split(',');
        }
    },
    
    start: function FixedOddsBettingService_FixedOddsBettingService$start() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('Start');
        if (this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.start) {
            this._startInternalPlaceBetSlip$1();
        }
    },
    
    registerBetPlacementStateChangedListener: function FixedOddsBettingService_FixedOddsBettingService$registerBetPlacementStateChangedListener(betPlacementStateChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('RegisterBetPlacementStateChangedListener');
        this._betPlacementStateChangedListeners$1.registerListener(betPlacementStateChangedListener);
    },
    
    unregisterBetPlacementStateChangedListener: function FixedOddsBettingService_FixedOddsBettingService$unregisterBetPlacementStateChangedListener(betPlacementStateChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('UnregisterBetPlacementStateChangedListener');
        this._betPlacementStateChangedListeners$1.unregisterListener(betPlacementStateChangedListener);
    },
    
    _fireBetPlacementStateChangedEvent$1: function FixedOddsBettingService_FixedOddsBettingService$_fireBetPlacementStateChangedEvent$1(placementState) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('FireBetPlacementStateChangedEvent');
        this._betPlacementStateChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBetPlacementStateChanged();
        }));
    },
    
    registerOddsTypeChangedListener: function FixedOddsBettingService_FixedOddsBettingService$registerOddsTypeChangedListener(oddsTypeChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('RegisterOddsTypeChangedListener');
        this._oddsTypeChangedListeners$1.registerListener(oddsTypeChangedListener);
    },
    
    unregisterOddsTypeChangedListener: function FixedOddsBettingService_FixedOddsBettingService$unregisterOddsTypeChangedListener(oddsTypeChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('UnregisterOddsTypeChangedListener');
        this._oddsTypeChangedListeners$1.unregisterListener(oddsTypeChangedListener);
    },
    
    _fireOddsTypeChangedEvent$1: function FixedOddsBettingService_FixedOddsBettingService$_fireOddsTypeChangedEvent$1() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('FireOddsTypeChangedEvent');
        this._oddsTypeChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onOddsTypeChanged(this);
        }));
    },
    
    registerBettingPreferencesChangedListener: function FixedOddsBettingService_FixedOddsBettingService$registerBettingPreferencesChangedListener(bettingPreferencesChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('RegisterBettingPreferencesChangedListener');
        this._bettingPreferencesChangedListeners$1.registerListener(bettingPreferencesChangedListener);
    },
    
    unregisterBettingPreferencesChangedListener: function FixedOddsBettingService_FixedOddsBettingService$unregisterBettingPreferencesChangedListener(bettingPreferencesChangedListener) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('UnregisterBettingPreferencesChangedListener');
        this._bettingPreferencesChangedListeners$1.unregisterListener(bettingPreferencesChangedListener);
    },
    
    _fireBettingPreferencesChangedEvent$1: function FixedOddsBettingService_FixedOddsBettingService$_fireBettingPreferencesChangedEvent$1() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('FireBettingPreferencesChangedEvent');
        this._bettingPreferencesChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBettingPreferencesChanged();
        }));
    },
    
    getBetHistoryDetails: function FixedOddsBettingService_FixedOddsBettingService$getBetHistoryDetails(successCallback, failureCallback, from, to, pageNumber, pageSize, orderBy, orderDesc, betStateTypes, betOutcomeTypes) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('GetBetHistoryDetails from=[{0}] to=[{1}] pageNumber=[{2}] pageSize=[{3}] orderBy=[{4}] orderDesc=[{5}] betStateTypes=[{6}] betOutcomeTypes=[{7}]', from, to, pageNumber, pageSize, orderBy, orderDesc, betStateTypes, betOutcomeTypes));
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'GetBetHistoryDetails', { from: Framework.JSONFormat.formatDateTime(from), to: Framework.JSONFormat.formatDateTime(to), pageNumber: pageNumber, pageSize: pageSize, orderBy: orderBy, orderDesc: orderDesc, betStateTypes: betStateTypes, betOutcomeTypes: betOutcomeTypes }, successCallback, Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetBetHistoryDetails exception' + exception.message);
            failureCallback.invoke(exception);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    placeBetSlip: function FixedOddsBettingService_FixedOddsBettingService$placeBetSlip(selections, betSlipCalculation, betSlip, isBetConfirmationScreenShownBeforePlacementOverride) {
        this.resetBetSlip();
        this._selections$1 = Framework.JsonUtil.deserialize(Framework.JsonUtil.serialize(selections));
        this._betSlipInbound$1 = new FixedOddsBettingService.BetSlipInbound(betSlip.IsFree, betSlip.Bets.clone());
        this._betSlipCalculation$1 = betSlipCalculation.clone();
        this._isBetConfirmationScreenShownBeforePlacementOverride$1 = isBetConfirmationScreenShownBeforePlacementOverride;
        if (this._areasWhereBetPlacementStays$1.contains(this._navigationService$1.getPageArea().toLowerCase())) {
            this._startInternalPlaceBetSlip$1();
        }
        else {
            this._betPlacementState$1 = FixedOddsBettingService.BetPlacementState.start;
            this._navigationService$1.goTo(this._areasWhereBetPlacementStays$1[0], this._navigationService$1.getPageFilter());
        }
    },
    
    _startInternalPlaceBetSlip$1: function FixedOddsBettingService_FixedOddsBettingService$_startInternalPlaceBetSlip$1() {
        this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.start, true, FixedOddsBettingService.BetTerminatedState.notApplicableState);
        if ((this._preferences$1.IsBetConfirmationScreenShownBeforePlacement && this._isBetConfirmationScreenShownBeforePlacementOverride$1 !== FixedOddsBettingService.OverrideToShowConfirmation.overrideToNotShowConfirmation) || this._isBetConfirmationScreenShownBeforePlacementOverride$1 === FixedOddsBettingService.OverrideToShowConfirmation.overrideToShowConfirmation) {
            this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore, true, FixedOddsBettingService.BetTerminatedState.notApplicableState);
        }
        else {
            this._gracePeriodRemaining$1 = this._preferences$1.BetGracePeriod || 0;
            this._makeBetSlipCall$1('');
        }
    },
    
    confirmBetSlip: function FixedOddsBettingService_FixedOddsBettingService$confirmBetSlip(securityCode) {
        this._makeBetSlipCall$1(securityCode);
    },
    
    _makeBetSlipCall$1: function FixedOddsBettingService_FixedOddsBettingService$_makeBetSlipCall$1(securityCode) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('ConfirmBetSlip');
        this._gracePeriodRemaining$1 = this._preferences$1.BetGracePeriod || 0;
        if (this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore || this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.start) {
            this._serverPlaceBetSlip$1();
        }
        else {
            this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.waiting, true, FixedOddsBettingService.BetTerminatedState.notApplicableState);
            this._adjustBetSlipCalculation$1();
            this._adjustBetSlipInbound$1();
            if (this._isSecondConfirmation$1) {
                this._serverPlaceBetSlip$1();
            }
            else {
                this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'ConfirmBetSlipUsingConfirmations', { IDFOBetSlip: this._betSlipOutbound$1.IDFOBetSlip, betSlipStatus: this._betSlipOutbound$1.Status, rejectOnChanges: true, securityCode: securityCode }, Delegate.create(this, function(result) {
                    this._isSecondConfirmation$1 = true;
                    this._handleBetPlacementSuccess$1(result);
                }), Delegate.create(this, function(exception) {
                    FixedOddsBettingService.FixedOddsBettingService._log$1.debug('ConfirmBetSlipUsingConfirmations exception' + exception.message);
                    this._handleBetPlacementException$1(exception);
                }));
            }
        }
    },
    
    _serverPlaceBetSlip$1: function FixedOddsBettingService_FixedOddsBettingService$_serverPlaceBetSlip$1() {
        this._isSecondConfirmation$1 = false;
        this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.waiting, false, FixedOddsBettingService.BetTerminatedState.notApplicableState);
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'PlaceBetSlip', { betSlip: this._betSlipInbound$1 }, Delegate.create(this, function(result) {
            this._handleBetPlacementSuccess$1(result);
        }), Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('PlaceBetSlip exception' + exception.message);
            this._handleBetPlacementException$1(exception);
        }));
    },
    
    rejectBetSlip: function FixedOddsBettingService_FixedOddsBettingService$rejectBetSlip() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('RejectBetSlip');
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'RejectBetSlip', { IDFOBetSlip: this._betSlipOutbound$1.IDFOBetSlip, betSlipStatus: this._betSlipOutbound$1.Status }, Delegate.create(this, function(result) {
            this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.rejected, true, FixedOddsBettingService.BetTerminatedState.manualRejection);
        }), Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('RejectBetSlip exception' + exception.message);
            this._handleBetPlacementException$1(exception);
        }));
    },
    
    resetBetSlip: function FixedOddsBettingService_FixedOddsBettingService$resetBetSlip() {
        this._selections$1 = {};
        this._betPlacementState$1 = FixedOddsBettingService.BetPlacementState.none;
        this._betTerminatedState$1 = FixedOddsBettingService.BetTerminatedState.notApplicableState;
        this._betSlipInbound$1 = null;
        this._betSlipOutbound$1 = null;
        this._isSecondConfirmation$1 = false;
        this._betSlipCalculation$1 = [];
        this._gracePeriodRemaining$1 = 0;
    },
    
    gracePeriodTimedOut: function FixedOddsBettingService_FixedOddsBettingService$gracePeriodTimedOut() {
        this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.rejected, true, FixedOddsBettingService.BetTerminatedState.gracePeriodTimeoutRejection);
    },
    
    _getBetSlipStatusInternal$1: function FixedOddsBettingService_FixedOddsBettingService$_getBetSlipStatusInternal$1() {
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'GetBetSlipStatus', { IDFOBetSlip: this._betSlipOutbound$1.IDFOBetSlip }, Delegate.create(this, function(result) {
            this._betSlipOutbound$1.Status = result;
            this._updateBetPlacementState$1(this._betSlipOutbound$1.Status.State, false, FixedOddsBettingService.BetTerminatedState.notApplicableState);
            if (this._betSlipOutbound$1.Status.State === FixedOddsBettingService.BetPlacementState.waiting) {
                window.setTimeout(Delegate.create(this, this._getBetSlipStatusInternal$1), 5000);
            }
        }), Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetBetSlipStatus exception' + exception.message);
            this._handleBetPlacementException$1(exception);
        }));
    },
    
    _handleBetPlacementException$1: function FixedOddsBettingService_FixedOddsBettingService$_handleBetPlacementException$1(exception) {
        this._userService$1.handleSessionTimeout(exception);
        this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.failed, true, (exception && Framework.ExceptionUtil.getExceptionDetails(exception).get_exceptionType() === 'Com.Finsoft.Warp.Connecticut.SessionTimeoutException') ? FixedOddsBettingService.BetTerminatedState.sessionTimeOutFailure : FixedOddsBettingService.BetTerminatedState.generalFailure);
    },
    
    checkBetSlipStatusForSessionTimeout: function FixedOddsBettingService_FixedOddsBettingService$checkBetSlipStatusForSessionTimeout() {
        if (this._userService$1.isLoggedIn() && this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.failed && this._betTerminatedState$1 === FixedOddsBettingService.BetTerminatedState.sessionTimeOutFailure) {
            this._updateBetPlacementState$1(FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore, false, FixedOddsBettingService.BetTerminatedState.notApplicableState);
            return true;
        }
        else {
            return false;
        }
    },
    
    _handleBetPlacementSuccess$1: function FixedOddsBettingService_FixedOddsBettingService$_handleBetPlacementSuccess$1(result) {
        this._betSlipOutbound$1 = FixedOddsBettingService.FixedOddsBettingService._adjustBetSlipOutboundForFreeBet$1(result, this._betSlipInbound$1.IsFree);
        var placementState = (this._isSecondConfirmation$1 && this._checkIfBetRejectedButStillValid$1()) ? FixedOddsBettingService.BetPlacementState.confirmationRequired : this._betSlipOutbound$1.Status.State;
        this._updateBetPlacementState$1(placementState, true, FixedOddsBettingService.BetTerminatedState.notApplicableState);
        if (this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.placed) {
            this._accountService$1.fetchAccountsDetails();
        }
        else if (this._betPlacementState$1 === FixedOddsBettingService.BetPlacementState.waiting) {
            this._getBetSlipStatusInternal$1();
        }
    },
    
    _preferences$1: null,
    
    _updateLocalPreferences$1: function FixedOddsBettingService_FixedOddsBettingService$_updateLocalPreferences$1(preferences, firePreferencesChangedEvent) {
        if (!FixedOddsBettingService.FixedOddsBettingPreferences.equals(this._preferences$1, preferences)) {
            if (firePreferencesChangedEvent) {
                this._fireBettingPreferencesChangedEvent$1();
            }
            var oldOddsType = this._preferences$1.OddsType;
            this._preferences$1 = preferences;
            if (!String.equals(oldOddsType, preferences.OddsType, true)) {
                this._fireOddsTypeChangedEvent$1();
            }
        }
    },
    
    setOddsType: function FixedOddsBettingService_FixedOddsBettingService$setOddsType(oddsType) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('SetOddsType oddsType=[{0}]', oddsType));
        if (String.equals(this._preferences$1.OddsType, oddsType, true)) {
            return;
        }
        if (FixedOddsBettingService.FixedOddsBettingPreferences.isOddsTypeValid(oddsType)) {
            this._preferences$1.OddsType = oddsType;
            this._fireOddsTypeChangedEvent$1();
        }
        else {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('SetOddsType invalid oddsType=[{0}]', oddsType));
        }
    },
    
    isOddsTypeValid: function FixedOddsBettingService_FixedOddsBettingService$isOddsTypeValid(oddsType) {
        return FixedOddsBettingService.FixedOddsBettingPreferences.isOddsTypeValid(oddsType.toUpperCase());
    },
    
    getPreferences: function FixedOddsBettingService_FixedOddsBettingService$getPreferences() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetPreferences');
        return this._preferences$1;
    },
    
    fetchPreferences: function FixedOddsBettingService_FixedOddsBettingService$fetchPreferences() {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug('FetchPreferences');
        this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'GetPreferences', {}, Delegate.create(this, function(result) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetPreferences successfull');
            if (result) {
                this._updateLocalPreferences$1(result, true);
            }
        }), Delegate.create(this, function(exception) {
            FixedOddsBettingService.FixedOddsBettingService._log$1.debug('GetPreferences exception' + exception.message);
            this._userService$1.handleSessionTimeout(exception);
        }));
    },
    
    setPreferences: function FixedOddsBettingService_FixedOddsBettingService$setPreferences(successCallback, failureCallback, preferences) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('SetPreferences preferences=[{0}]', Framework.DictionaryUtil.dumpObjectToString(preferences)));
        if (!FixedOddsBettingService.FixedOddsBettingPreferences.equals(this._preferences$1, preferences)) {
            this._environment.invokeAsync(FixedOddsBettingService.FixedOddsBettingService._serviceName$1, 'SetPreferences', { fixedOddsBettingPreferences: preferences }, Delegate.create(this, function(result) {
                preferences.BetGracePeriod = this._preferences$1.BetGracePeriod;
                this._updateLocalPreferences$1(preferences, false);
                successCallback.invoke(result);
            }), Delegate.create(this, function(exception) {
                FixedOddsBettingService.FixedOddsBettingService._log$1.debug('SetPreferences exception' + exception.message);
                failureCallback.invoke(exception);
                this._userService$1.handleSessionTimeout(exception);
            }));
        }
        else {
            successCallback.invoke(null);
        }
    },
    
    formatOdds: function FixedOddsBettingService_FixedOddsBettingService$formatOdds(IDFOPriceType, priceUp, priceDown) {
        FixedOddsBettingService.FixedOddsBettingService._log$1.debug(String.format('FormatOdds IDFOPriceType=[{0}] priceUp=[{1}] priceDown=[{2}]', IDFOPriceType, priceUp, priceDown));
        if ('SP' === IDFOPriceType) {
            return 'SP';
        }
        if ('WPD' === IDFOPriceType || 'PPD' === IDFOPriceType || 'SPD' === IDFOPriceType) {
            return 'DIV';
        }
        if ((!priceUp) || (!priceDown)) {
            return '-';
        }
        if (String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.american, this._preferences$1.OddsType, true)) {
            return String.format('{0} {1}', (priceUp > priceDown) ? '+' : '-', (priceUp > priceDown) ? 100 * priceUp / priceDown : 100 * priceDown / priceUp);
        }
        if (String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.decimals, this._preferences$1.OddsType, true)) {
            return (((priceUp + priceDown) / priceDown)).toFixed(2);
        }
        if (String.equals(FixedOddsBettingService.FixedOddsBettingPreferences.fractions, this._preferences$1.OddsType, true)) {
            return (priceUp === priceDown) ? 'EVS' : String.format('{0}/{1}', priceUp, priceDown);
        }
        return String.Empty;
    },
    
    shouldPlacementStayInCurrentArea: function FixedOddsBettingService_FixedOddsBettingService$shouldPlacementStayInCurrentArea() {
        return this._areasWhereBetPlacementStays$1.contains(this._navigationService$1.getPageArea().toLowerCase());
    }
}


////////////////////////////////////////////////////////////////////////////////
// FixedOddsBettingService.Selection

FixedOddsBettingService.Selection = function FixedOddsBettingService_Selection() {
}
FixedOddsBettingService.Selection.createSelection = function FixedOddsBettingService_Selection$createSelection(IDFOPriceType, activePriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, IsTrapBettingOptionOn, HADValue, handicap, upperBand, lowerBand, eachWayReduction, eachWayPlaceTerms, IDFOSelection, selectionName, priceUp, priceDown, activeBetTypes, FixedOddsPriceTypes, selectionHashCode, isTradable) {
    var result = new FixedOddsBettingService.Selection();
    result.IDFOPriceType = IDFOPriceType;
    if (Framework.ScriptSharpQuirks.isNumberNull(activePriceType)) {
        result.ActivePriceType = -1;
        for (var i = 0; i < FixedOddsBettingService.PriceType.getValidPriceTypesForSingle().length; i++) {
            result.ActivePriceType = IDFOPriceType.indexOf(FixedOddsBettingService.PriceType.getValidPriceTypesForSingle()[i]);
            if (result.ActivePriceType >= 0) {
                break;
            }
        }
    }
    else {
        result.ActivePriceType = activePriceType;
    }
    result.IDFOEvent = IDFOEvent;
    result.EventName = eventName;
    result.IDFOMarket = IDFOMarket;
    result.MarketName = marketName;
    result.MTag = MTag;
    result.TTagLeft = TTagLeft;
    result.TTagRight = TTagRight;
    result.CTag = CTag;
    result.IsTrapBettingOptionOn = IsTrapBettingOptionOn;
    result.IsTrap = false;
    result.HADValue = HADValue;
    result.Handicap = handicap;
    result.UpperBand = upperBand;
    result.LowerBand = lowerBand;
    var filteredEachWayReduction = [];
    var filteredEachWayPlaceTerms = [];
    if ((eachWayReduction) && (eachWayPlaceTerms)) {
        for (var i = 0; i < eachWayReduction.length; i++) {
            if (!(eachWayReduction[i] === 1 && eachWayPlaceTerms[i] === 1)) {
                filteredEachWayReduction.add(eachWayReduction[i]);
                filteredEachWayPlaceTerms.add(eachWayPlaceTerms[i]);
            }
        }
    }
    result.EachWayReduction = filteredEachWayReduction;
    result.EachWayPlaceTerms = filteredEachWayPlaceTerms;
    result.ActiveEachWay = -1;
    result.IDFOSelection = IDFOSelection;
    result.SelectionName = selectionName;
    result.PriceUp = priceUp;
    result.PriceDown = priceDown;
    result.ActiveBetTypes = activeBetTypes;
    result.FixedOddsPriceTypes = FixedOddsPriceTypes;
    result.SelectionHashCode = selectionHashCode;
    result.IsTradable = isTradable;
    return result;
}
FixedOddsBettingService.Selection.createScorecastSelection = function FixedOddsBettingService_Selection$createScorecastSelection(IDFOPriceType, IDFOEvent, eventName, IDFOMarket1GS, marketName1GS, MTag, TTagLeft, TTagRight, CTag, IDFOSelection1GS, selectionName1GS, priceUp1GS, priceDown1GS, IDFOEventScorecast, IDFOMarketCS, marketNameCS, IDFOSelectionCS, selectionNameCS, priceUpCS, priceDownCS, selectionHashCode, isTradable) {
    var result = new FixedOddsBettingService.Selection();
    result.IDFOPriceType = IDFOPriceType;
    result.ActivePriceType = 0;
    result.IDFOEvent = IDFOEvent;
    result.EventName = eventName;
    result.IDFOMarket = IDFOMarket1GS;
    result.MarketName = marketName1GS;
    result.MTag = MTag;
    result.TTagLeft = TTagLeft;
    result.TTagRight = TTagRight;
    result.CTag = CTag;
    result.IsTrapBettingOptionOn = false;
    result.IsTrap = false;
    result.EachWayReduction = [];
    result.EachWayPlaceTerms = [];
    result.ActiveEachWay = -1;
    result.IDFOSelection = IDFOSelection1GS;
    result.SelectionName = selectionName1GS;
    result.PriceUp = priceUp1GS;
    result.PriceDown = priceDown1GS;
    result.IDFOEventScorecast = IDFOEventScorecast;
    result.IDFOMarketCS = IDFOMarketCS;
    result.MarketNameCS = marketNameCS;
    result.IDFOSelectionCS = IDFOSelectionCS;
    result.SelectionNameCS = selectionNameCS;
    result.PriceUpCS = priceUpCS;
    result.PriceDownCS = priceDownCS;
    result.FixedOddsPriceTypes = [];
    result.SelectionHashCode = selectionHashCode;
    result.IsTradable = isTradable;
    return result;
}
FixedOddsBettingService.Selection.createSectionsListSelection = function FixedOddsBettingService_Selection$createSectionsListSelection(IDFOPriceType, activePriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, HADValue, handicap, upperBand, lowerBand, IDFOSelection, selectionName, priceUp, priceDown) {
    var result = new FixedOddsBettingService.Selection();
    result.IDFOPriceType = IDFOPriceType;
    if (Framework.ScriptSharpQuirks.isNumberNull(activePriceType)) {
        result.ActivePriceType = -1;
        for (var i = 0; i < FixedOddsBettingService.PriceType.getValidPriceTypesForSingle().length; i++) {
            result.ActivePriceType = IDFOPriceType.indexOf(FixedOddsBettingService.PriceType.getValidPriceTypesForSingle()[i]);
            if (result.ActivePriceType >= 0) {
                break;
            }
        }
    }
    else {
        result.ActivePriceType = activePriceType;
    }
    result.IDFOEvent = IDFOEvent;
    result.EventName = eventName;
    result.IDFOMarket = IDFOMarket;
    result.MarketName = marketName;
    result.MTag = MTag;
    result.TTagLeft = TTagLeft;
    result.TTagRight = TTagRight;
    result.CTag = CTag;
    result.IsTrapBettingOptionOn = false;
    result.IsTrap = false;
    result.HADValue = HADValue;
    result.Handicap = handicap;
    result.UpperBand = upperBand;
    result.LowerBand = lowerBand;
    result.EachWayReduction = [];
    result.EachWayPlaceTerms = [];
    result.ActiveEachWay = -1;
    result.IDFOSelection = IDFOSelection;
    result.SelectionName = selectionName;
    result.PriceUp = priceUp;
    result.PriceDown = priceDown;
    result.ActiveBetTypes = null;
    result.FixedOddsPriceTypes = [];
    result.SelectionHashCode = null;
    result.IsTradable = false;
    return result;
}
FixedOddsBettingService.Selection.createRacePoolSelection = function FixedOddsBettingService_Selection$createRacePoolSelection(IDFOPriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, IDFOSelection, selectionName) {
    var result = new FixedOddsBettingService.Selection();
    result.IDFOPriceType = [ IDFOPriceType ];
    result.ActivePriceType = 0;
    result.IDFOEvent = IDFOEvent;
    result.EventName = eventName;
    result.IDFOMarket = IDFOMarket;
    result.MarketName = marketName;
    result.MTag = MTag;
    result.TTagLeft = TTagLeft;
    result.TTagRight = TTagRight;
    result.CTag = CTag;
    result.IsTrapBettingOptionOn = false;
    result.IsTrap = true;
    result.HADValue = null;
    result.Handicap = null;
    result.UpperBand = null;
    result.LowerBand = null;
    result.EachWayReduction = [];
    result.EachWayPlaceTerms = [];
    result.ActiveEachWay = -1;
    result.IDFOSelection = IDFOSelection;
    result.SelectionName = selectionName;
    result.PriceUp = null;
    result.PriceDown = null;
    result.ActiveBetTypes = null;
    result.FixedOddsPriceTypes = [];
    result.SelectionHashCode = null;
    result.IsTradable = false;
    return result;
}
FixedOddsBettingService.Selection.prototype = {
    IDFOPriceType: null,
    ActivePriceType: 0,
    IDFOEvent: null,
    EventName: null,
    IDFOMarket: null,
    MarketName: null,
    MTag: null,
    TTagLeft: null,
    TTagRight: null,
    CTag: null,
    IsTrapBettingOptionOn: false,
    IsTrap: false,
    HADValue: null,
    Handicap: null,
    UpperBand: null,
    LowerBand: null,
    EachWayReduction: null,
    EachWayPlaceTerms: null,
    ActiveEachWay: 0,
    IDFOSelection: null,
    SelectionName: null,
    PriceUp: null,
    PriceDown: null,
    IDFOEventScorecast: null,
    IDFOMarketCS: null,
    MarketNameCS: null,
    IDFOSelectionCS: null,
    SelectionNameCS: null,
    PriceUpCS: null,
    PriceDownCS: null,
    IsActive: true,
    ActiveBetTypes: null,
    SelectionHashCode: null,
    IsTradable: false,
    FixedOddsPriceTypes: null
}


FixedOddsBettingService.BetPlacementState.createClass('FixedOddsBettingService.BetPlacementState');
FixedOddsBettingService.BetTerminatedState.createClass('FixedOddsBettingService.BetTerminatedState');
FixedOddsBettingService.CalculatedBet.createClass('FixedOddsBettingService.CalculatedBet');
FixedOddsBettingService.BetInbound.createClass('FixedOddsBettingService.BetInbound');
FixedOddsBettingService.BetLeg.createClass('FixedOddsBettingService.BetLeg');
FixedOddsBettingService.BetSlipInbound.createClass('FixedOddsBettingService.BetSlipInbound');
FixedOddsBettingService.BetSlipOutbound.createClass('FixedOddsBettingService.BetSlipOutbound');
FixedOddsBettingService.BetOutbound.createClass('FixedOddsBettingService.BetOutbound');
FixedOddsBettingService.BetType.createClass('FixedOddsBettingService.BetType');
FixedOddsBettingService.BetSlipStatus.createClass('FixedOddsBettingService.BetSlipStatus');
FixedOddsBettingService.BetTypesAndReturns.createClass('FixedOddsBettingService.BetTypesAndReturns');
FixedOddsBettingService.PotentialReturn.createClass('FixedOddsBettingService.PotentialReturn');
FixedOddsBettingService.PriceType.createClass('FixedOddsBettingService.PriceType');
FixedOddsBettingService.FixedOddsBettingPreferences.createClass('FixedOddsBettingService.FixedOddsBettingPreferences');
FixedOddsBettingService.FixedOddsBettingService.createClass('FixedOddsBettingService.FixedOddsBettingService', Framework.AbstractService, Framework.IPageWillChangeListener, UserService.IUserChangedListener);
FixedOddsBettingService.Selection.createClass('FixedOddsBettingService.Selection');
FixedOddsBettingService.BetPlacementState.none = -2;
FixedOddsBettingService.BetPlacementState.start = -1;
FixedOddsBettingService.BetPlacementState.confirmationRequiredBefore = 0;
FixedOddsBettingService.BetPlacementState.confirmationRequired = 1;
FixedOddsBettingService.BetPlacementState.placed = 2;
FixedOddsBettingService.BetPlacementState.acceptable = 3;
FixedOddsBettingService.BetPlacementState.rejected = 4;
FixedOddsBettingService.BetPlacementState.waiting = 5;
FixedOddsBettingService.BetPlacementState.failed = 6;
FixedOddsBettingService.BetTerminatedState.notApplicableState = -1;
FixedOddsBettingService.BetTerminatedState.sessionTimeOutFailure = 0;
FixedOddsBettingService.BetTerminatedState.generalFailure = 1;
FixedOddsBettingService.BetTerminatedState.betFailedMasks = [ FixedOddsBettingService.BetTerminatedState.sessionTimeOutFailure, FixedOddsBettingService.BetTerminatedState.generalFailure ];
FixedOddsBettingService.BetTerminatedState.manualRejection = 2;
FixedOddsBettingService.BetTerminatedState.displayStatusRejection = 3;
FixedOddsBettingService.BetTerminatedState.generalRejection = 4;
FixedOddsBettingService.BetTerminatedState.gracePeriodTimeoutRejection = 5;
FixedOddsBettingService.BetTerminatedState.betRejectedMasks = [ FixedOddsBettingService.BetTerminatedState.manualRejection, FixedOddsBettingService.BetTerminatedState.displayStatusRejection, FixedOddsBettingService.BetTerminatedState.generalRejection, FixedOddsBettingService.BetTerminatedState.gracePeriodTimeoutRejection ];
FixedOddsBettingService.BetSlipStatus.accepted = 1;
FixedOddsBettingService.BetSlipStatus.acceptable = 2;
FixedOddsBettingService.BetSlipStatus.rejected = 4;
FixedOddsBettingService.BetSlipStatus.priceChanged = 8;
FixedOddsBettingService.BetSlipStatus.handicapChanged = 16;
FixedOddsBettingService.BetSlipStatus.bandChanged = 32;
FixedOddsBettingService.BetSlipStatus.reoffered = 64;
FixedOddsBettingService.BetSlipStatus.reofferTimeout = 128;
FixedOddsBettingService.BetSlipStatus.topupRequired = 256;
FixedOddsBettingService.BetSlipStatus.maxTakeoutViolation = 512;
FixedOddsBettingService.BetSlipStatus.waiting = 1024;
FixedOddsBettingService.BetSlipStatus.eachWayChanged = 2048;
FixedOddsBettingService.BetSlipStatus.abortProcessing = 4096;
FixedOddsBettingService.BetSlipStatus.securityCodeRequiredForTopup = 16384;
FixedOddsBettingService.BetSlipStatus.confirmationMasks = [ FixedOddsBettingService.BetSlipStatus.priceChanged, FixedOddsBettingService.BetSlipStatus.handicapChanged, FixedOddsBettingService.BetSlipStatus.bandChanged, FixedOddsBettingService.BetSlipStatus.reoffered, FixedOddsBettingService.BetSlipStatus.topupRequired, FixedOddsBettingService.BetSlipStatus.maxTakeoutViolation, FixedOddsBettingService.BetSlipStatus.eachWayChanged, FixedOddsBettingService.BetSlipStatus.abortProcessing, FixedOddsBettingService.BetSlipStatus.securityCodeRequiredForTopup ];
FixedOddsBettingService.PriceType._validPriceTypesForSingle = [ 'AP', 'EP', 'BP', 'CP', 'SC', 'SP', 'WPD' ];
FixedOddsBettingService.FixedOddsBettingPreferences.american = 'AMERICAN';
FixedOddsBettingService.FixedOddsBettingPreferences.decimals = 'DECIMALS';
FixedOddsBettingService.FixedOddsBettingPreferences.fractions = 'FRACTIONS';
FixedOddsBettingService.FixedOddsBettingService._serviceName$1 = 'FixedOddsBettingService';
FixedOddsBettingService.FixedOddsBettingService._log$1 = Framework.Logger.getLog(FixedOddsBettingService.FixedOddsBettingService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('BetSlipService');

////////////////////////////////////////////////////////////////////////////////
// BetSlipService.IBetSlipCalculationChangedListener

BetSlipService.IBetSlipCalculationChangedListener = function() { };
BetSlipService.IBetSlipCalculationChangedListener.prototype = {
    onBetSlipCalculationChanged : null
}
BetSlipService.IBetSlipCalculationChangedListener.createInterface('BetSlipService.IBetSlipCalculationChangedListener');


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.IAllowedBetTypesChangedListener

BetSlipService.IAllowedBetTypesChangedListener = function() { };
BetSlipService.IAllowedBetTypesChangedListener.prototype = {
    onAllowedBetTypesChanged : null
}
BetSlipService.IAllowedBetTypesChangedListener.createInterface('BetSlipService.IAllowedBetTypesChangedListener');


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.IBetSlipSelectionsUpdateListener

BetSlipService.IBetSlipSelectionsUpdateListener = function() { };
BetSlipService.IBetSlipSelectionsUpdateListener.prototype = {
    onBetSlipSelectionsUpdate : null
}
BetSlipService.IBetSlipSelectionsUpdateListener.createInterface('BetSlipService.IBetSlipSelectionsUpdateListener');


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.ISelectionsRemovedListener

BetSlipService.ISelectionsRemovedListener = function() { };
BetSlipService.ISelectionsRemovedListener.prototype = {
    onSelectionsRemoved : null
}
BetSlipService.ISelectionsRemovedListener.createInterface('BetSlipService.ISelectionsRemovedListener');


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.ISelectionsAddedListener

BetSlipService.ISelectionsAddedListener = function() { };
BetSlipService.ISelectionsAddedListener.prototype = {
    onSelectionsAdded : null
}
BetSlipService.ISelectionsAddedListener.createInterface('BetSlipService.ISelectionsAddedListener');


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.BetSlipService

BetSlipService.BetSlipService = function BetSlipService_BetSlipService() {
    this._currentTimeout$1 = -1;
    this._selectionsAddedListeners$1 = new Framework.ListenerInvoker(true);
    this._selectionsRemovedListeners$1 = new Framework.ListenerInvoker(true);
    this._allowedBetTypesChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._betSlipCalculationChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._betSlipSelectionsUpdateListeners$1 = new Framework.ListenerInvoker(true);
    this._selections$1 = {};
    this._previousSelections$1 = {};
    this._selectionsInterRelationColors$1 = {};
    this._allowedBetTypes$1 = [];
    this._isEachWayPerBetType$1 = {};
    this._stakePerBetType$1 = {};
    this._stakePerSelection$1 = {};
    this._potentialReturns$1 = new FixedOddsBettingService.PotentialReturn();
    this._betSlipCalculation$1 = new FixedOddsBettingService.PotentialReturn();
    BetSlipService.BetSlipService.constructBase(this);
}
BetSlipService.BetSlipService.prototype = {
    _liveUpdatePeriod$1: 10000,
    _betSlipLiveUpdate$1: true,
    _betSlipUpdateInProgress$1: false,
    
    onPageWillChange: function BetSlipService_BetSlipService$onPageWillChange() {
        this._environment.storeState(BetSlipService.BetSlipService._serviceName$1, this._getState$1());
    },
    
    _accountService$1: null,
    
    setAccountService: function BetSlipService_BetSlipService$setAccountService(accountService) {
        BetSlipService.BetSlipService._log$1.debug('SetAccountService');
        this._accountService$1 = accountService;
    },
    
    _fixedOddsBettingService$1: null,
    
    setFixedOddsBettingService: function BetSlipService_BetSlipService$setFixedOddsBettingService(fixedOddsBettingService) {
        BetSlipService.BetSlipService._log$1.debug('SetFixedOddsBettingService');
        this._fixedOddsBettingService$1 = fixedOddsBettingService;
        this._fixedOddsBettingService$1.registerBetPlacementStateChangedListener(this);
    },
    
    onBetPlacementStateChanged: function BetSlipService_BetSlipService$onBetPlacementStateChanged() {
        BetSlipService.BetSlipService._log$1.debug('OnBetPlacementStateChanged');
        if ((this._fixedOddsBettingService$1.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.placed || this._fixedOddsBettingService$1.get_betPlacementState() === FixedOddsBettingService.BetPlacementState.rejected) && !this._retainSelectionsAfterPlacement$1) {
            this.removeAllSelections();
        }
    },
    
    _navigationService$1: null,
    
    setNavigationService: function BetSlipService_BetSlipService$setNavigationService(navigationService) {
        BetSlipService.BetSlipService._log$1.debug('SetNavigationService');
        this._navigationService$1 = navigationService;
    },
    
    init: function BetSlipService_BetSlipService$init(environment, parameters) {
        BetSlipService.BetSlipService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        BetSlipService.BetSlipService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(BetSlipService.BetSlipService._serviceName$1);
        if (state) {
            this._setState$1(state);
        }
        if (Object.keyExists(parameters, 'bet-slip-live-update')) {
            this._betSlipLiveUpdate$1 = Boolean.parse(parameters['bet-slip-live-update']);
        }
    },
    
    start: function BetSlipService_BetSlipService$start() {
        BetSlipService.BetSlipService._log$1.debug('Start');
    },
    
    registerBetSlipSelectionsUpdateListener: function BetSlipService_BetSlipService$registerBetSlipSelectionsUpdateListener(betSlipSelectionsUpdateListener) {
        BetSlipService.BetSlipService._log$1.debug('RegisterBetSlipSelectionsUpdatedListener');
        this._betSlipSelectionsUpdateListeners$1.registerListener(betSlipSelectionsUpdateListener);
    },
    
    unregisterBetSlipSelectionsUpdateListener: function BetSlipService_BetSlipService$unregisterBetSlipSelectionsUpdateListener(betSlipSelectionsUpdateListener) {
        BetSlipService.BetSlipService._log$1.debug('UnregisterBetSlipSelectionsUpdatedListener');
        this._betSlipSelectionsUpdateListeners$1.unregisterListener(betSlipSelectionsUpdateListener);
    },
    
    _fireBetSlipSelectionsUpdateEvent$1: function BetSlipService_BetSlipService$_fireBetSlipSelectionsUpdateEvent$1() {
        BetSlipService.BetSlipService._log$1.debug('FireBetSlipSelectionsUpdatedEvent');
        this._betSlipSelectionsUpdateListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBetSlipSelectionsUpdate(this);
        }));
    },
    
    registerSelectionsAddedListener: function BetSlipService_BetSlipService$registerSelectionsAddedListener(selectionsAddedListener) {
        BetSlipService.BetSlipService._log$1.debug('RegisterSelectionsAddedListener');
        this._selectionsAddedListeners$1.registerListener(selectionsAddedListener);
    },
    
    unregisterSelectionsAddedListener: function BetSlipService_BetSlipService$unregisterSelectionsAddedListener(selectionsAddedListener) {
        BetSlipService.BetSlipService._log$1.debug('UnregisterSelectionsAddedListener');
        this._selectionsAddedListeners$1.unregisterListener(selectionsAddedListener);
    },
    
    _fireSelectionsAddedEvent$1: function BetSlipService_BetSlipService$_fireSelectionsAddedEvent$1(selection) {
        BetSlipService.BetSlipService._log$1.debug('FireSelectionsAddedEvent');
        this._selectionsAddedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onSelectionsAdded(this, selection);
        }));
    },
    
    registerSelectionsRemovedListener: function BetSlipService_BetSlipService$registerSelectionsRemovedListener(selectionsRemovedListener) {
        BetSlipService.BetSlipService._log$1.debug('RegisterSelectionsRemovedListener');
        this._selectionsRemovedListeners$1.registerListener(selectionsRemovedListener);
    },
    
    unregisterSelectionsRemovedListener: function BetSlipService_BetSlipService$unregisterSelectionsRemovedListener(selectionsRemovedListener) {
        BetSlipService.BetSlipService._log$1.debug('UnregisterSelectionsRemovedListener');
        this._selectionsRemovedListeners$1.unregisterListener(selectionsRemovedListener);
    },
    
    _fireSelectionsRemovedEvent$1: function BetSlipService_BetSlipService$_fireSelectionsRemovedEvent$1(selection) {
        BetSlipService.BetSlipService._log$1.debug('FireSelectionsRemovedEvent');
        this._selectionsRemovedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onSelectionsRemoved(this, selection);
        }));
    },
    
    registerAllowedBetTypesChangedListener: function BetSlipService_BetSlipService$registerAllowedBetTypesChangedListener(allowedBetTypesChangedListener) {
        BetSlipService.BetSlipService._log$1.debug('RegisterAllowedBetTypesChangedListener');
        this._allowedBetTypesChangedListeners$1.registerListener(allowedBetTypesChangedListener);
    },
    
    unregisterAllowedBetTypesChangedListener: function BetSlipService_BetSlipService$unregisterAllowedBetTypesChangedListener(allowedBetTypesChangedListener) {
        BetSlipService.BetSlipService._log$1.debug('UnregisterAllowedBetTypesChangedListener');
        this._allowedBetTypesChangedListeners$1.unregisterListener(allowedBetTypesChangedListener);
    },
    
    _fireAllowedBetTypesChangedEvent$1: function BetSlipService_BetSlipService$_fireAllowedBetTypesChangedEvent$1() {
        BetSlipService.BetSlipService._log$1.debug('FireAllowedBetTypesChangedEvent');
        this._allowedBetTypesChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onAllowedBetTypesChanged(this);
        }));
    },
    
    registerBetSlipCalculationChangedListener: function BetSlipService_BetSlipService$registerBetSlipCalculationChangedListener(betSlipCalculationChangedListener) {
        BetSlipService.BetSlipService._log$1.debug('RegisterBetSlipCalculationChangedListener');
        this._betSlipCalculationChangedListeners$1.registerListener(betSlipCalculationChangedListener);
    },
    
    unregisterBetSlipCalculationChangedListener: function BetSlipService_BetSlipService$unregisterBetSlipCalculationChangedListener(betSlipCalculationChangedListener) {
        BetSlipService.BetSlipService._log$1.debug('UnregisterBetSlipCalculationChangedListener');
        this._betSlipCalculationChangedListeners$1.unregisterListener(betSlipCalculationChangedListener);
    },
    
    _fireBetSlipCalculationChangedEvent$1: function BetSlipService_BetSlipService$_fireBetSlipCalculationChangedEvent$1() {
        BetSlipService.BetSlipService._log$1.debug('FireBetSlipCalculationChangedEvent');
        this._betSlipCalculationChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onBetSlipCalculationChanged(this);
        }));
    },
    
    _retainSelectionsAfterPlacement$1: false,
    
    getRetainSelectionsAfterPlacement: function BetSlipService_BetSlipService$getRetainSelectionsAfterPlacement() {
        BetSlipService.BetSlipService._log$1.debug('GetRetainSelectionsAfterPlacement');
        return this._retainSelectionsAfterPlacement$1;
    },
    
    _isFree$1: false,
    
    getIsFree: function BetSlipService_BetSlipService$getIsFree() {
        BetSlipService.BetSlipService._log$1.debug('GetIsFree');
        return this._isFree$1;
    },
    
    getSelections: function BetSlipService_BetSlipService$getSelections() {
        BetSlipService.BetSlipService._log$1.debug('GetSelections');
        if (!this._selections$1) {
            return {};
        }
        return this._selections$1;
    },
    
    getPreviousSelections: function BetSlipService_BetSlipService$getPreviousSelections() {
        BetSlipService.BetSlipService._log$1.debug('GetPreviousSelections');
        if (!this._previousSelections$1) {
            return {};
        }
        return this._previousSelections$1;
    },
    
    clearPreviousSelections: function BetSlipService_BetSlipService$clearPreviousSelections() {
        Object.clearKeys(this._previousSelections$1);
    },
    
    getSelectionsCount: function BetSlipService_BetSlipService$getSelectionsCount() {
        if (!this._selections$1) {
            return 0;
        }
        return Object.getKeyCount(this._selections$1);
    },
    
    getSelectionsInterRelationColors: function BetSlipService_BetSlipService$getSelectionsInterRelationColors() {
        return this._selectionsInterRelationColors$1;
    },
    
    getAllowedBetTypes: function BetSlipService_BetSlipService$getAllowedBetTypes() {
        BetSlipService.BetSlipService._log$1.debug('GetAllowedBetTypes');
        return this._allowedBetTypes$1;
    },
    
    getIsEachWayPerBetType: function BetSlipService_BetSlipService$getIsEachWayPerBetType() {
        BetSlipService.BetSlipService._log$1.debug('GetIsEachWayPerBetType');
        return this._isEachWayPerBetType$1;
    },
    
    getStakePerBetType: function BetSlipService_BetSlipService$getStakePerBetType() {
        BetSlipService.BetSlipService._log$1.debug('GetStakePerBetType');
        return this._stakePerBetType$1;
    },
    
    getStakePerSelection: function BetSlipService_BetSlipService$getStakePerSelection() {
        BetSlipService.BetSlipService._log$1.debug('GetStakePerSelection');
        return this._stakePerSelection$1;
    },
    
    getBetSlipCalculation: function BetSlipService_BetSlipService$getBetSlipCalculation() {
        BetSlipService.BetSlipService._log$1.debug('GetBetSlipCalculation');
        return this._betSlipCalculation$1;
    },
    
    _getBetSlipInbound$1: function BetSlipService_BetSlipService$_getBetSlipInbound$1() {
        var betLegs = this._getBetLegs$1(true, null);
        var betLegsDictionary = {};
        for (var j = 0; j < betLegs.length; j++) {
            if (!betLegs[j].IDFOEventScorecast) {
                betLegsDictionary[this.getSimpleSelectionKey(betLegs[j].IDFOSelection)] = betLegs[j];
            }
            else {
                betLegsDictionary[this._getScorecastLegKey1GS$1(betLegs[j].IDFOEventScorecast, betLegs[j].IDFOSelection, betLegs[j + 1].IDFOSelection)] = betLegs[j];
                betLegsDictionary[this._getScorecastLegKeyCS$1(betLegs[j].IDFOEventScorecast, betLegs[j].IDFOSelection, betLegs[j + 1].IDFOSelection)] = betLegs[j + 1];
                j++;
            }
        }
        var bets = new Array(Object.getKeyCount(this._stakePerBetType$1) + Object.getKeyCount(this._stakePerSelection$1));
        BetSlipService.BetSlipService._log$1.debug(String.format('GetBetSlipInbound total bets=[{0}] stakePerSelection.Count=[{1}]', bets.length, Object.getKeyCount(this._stakePerSelection$1)));
        var i = 0;
        var $dict1 = this._selections$1;
        for (var $key2 in $dict1) {
            var singleSelection = { key: $key2, value: $dict1[$key2] };
            if (Object.keyExists(this._stakePerSelection$1, singleSelection.key)) {
                var selection = singleSelection.value;
                var selectionKey = singleSelection.key;
                var currentBetLeg;
                if (!selection.IDFOEventScorecast) {
                    currentBetLeg = [ betLegsDictionary[selectionKey] ];
                }
                else {
                    currentBetLeg = [ betLegsDictionary[this._getScorecastLegKey1GS$1(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS)], betLegsDictionary[this._getScorecastLegKeyCS$1(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS)] ];
                }
                var IDFOMultiRacePool = null;
                var isPool = false;
                var winStake = this._stakePerSelection$1[selectionKey];
                var placeStake = (selection.ActiveEachWay < 0) ? null : winStake;
                var showStake = null;
                bets[i++] = new FixedOddsBettingService.BetInbound(currentBetLeg, 'S', 'Single', IDFOMultiRacePool, isPool, winStake, placeStake, showStake);
            }
        }
        var $dict3 = this._stakePerBetType$1;
        for (var $key4 in $dict3) {
            var stakePerBetTypeEntry = { key: $key4, value: $dict3[$key4] };
            var IDFOBetType = stakePerBetTypeEntry.key;
            var IDFOMultiRacePool = null;
            var isPool = false;
            var winStake = stakePerBetTypeEntry.value;
            var placeStake = (Object.keyExists(this._isEachWayPerBetType$1, IDFOBetType) && Boolean.parse(this._isEachWayPerBetType$1[IDFOBetType].toString())) ? winStake : null;
            var showStake = null;
            var forcedIDFOPriceType = BetSlipService.OverridingPriceTypes.priceTypeOverrides[IDFOBetType];
            var multiBetLegs = (String.isNullOrEmpty(forcedIDFOPriceType)) ? betLegs : this._getBetLegs$1(true, forcedIDFOPriceType);
            bets[i++] = new FixedOddsBettingService.BetInbound(multiBetLegs, IDFOBetType, this._getBetTypeName$1(IDFOBetType), IDFOMultiRacePool, isPool, winStake, placeStake, showStake);
        }
        return new FixedOddsBettingService.BetSlipInbound(this._isFree$1, bets);
    },
    
    _recalculateAllowedBetTypesAndReturnsSequence$1: 0,
    _recalculateEWReturnForBetType$1: 0,
    
    _getBetTypeName$1: function BetSlipService_BetSlipService$_getBetTypeName$1(IDFOBetType) {
        for (var i = 0; i < this._allowedBetTypes$1.length; i++) {
            if (!String.compare(IDFOBetType, this._allowedBetTypes$1[i].IDFOBetType, true)) {
                return this._allowedBetTypes$1[i].Name;
            }
        }
        return IDFOBetType;
    },
    
    _getState$1: function BetSlipService_BetSlipService$_getState$1() {
        return { isFree: this._isFree$1, selections: this._selections$1, previousSelections: this._previousSelections$1, allowedBetTypes: this._allowedBetTypes$1, stakePerBetType: this._stakePerBetType$1, stakePerSelection: this._stakePerSelection$1, betSlipCalculation: this._betSlipCalculation$1, isEachWayPerBetType: this._isEachWayPerBetType$1, potentialReturns: this._potentialReturns$1, retainSelectionsAfterPlacement: this._retainSelectionsAfterPlacement$1 };
    },
    
    _setState$1: function BetSlipService_BetSlipService$_setState$1(state) {
        this._isFree$1 = state['isFree'];
        this._selections$1 = state['selections'];
        this._previousSelections$1 = state['previousSelections'];
        this._allowedBetTypes$1 = state['allowedBetTypes'];
        this._stakePerBetType$1 = state['stakePerBetType'];
        this._stakePerSelection$1 = state['stakePerSelection'];
        this._betSlipCalculation$1 = state['betSlipCalculation'];
        this._isEachWayPerBetType$1 = state['isEachWayPerBetType'];
        this._potentialReturns$1 = state['potentialReturns'];
        this._retainSelectionsAfterPlacement$1 = state['retainSelectionsAfterPlacement'];
    },
    
    _getBetLegs$1: function BetSlipService_BetSlipService$_getBetLegs$1(forceEachWay, forcedIDFOPriceType) {
        var result = [];
        var systemTag = null;
        var interrelationTag = null;
        var $dict1 = this._selections$1;
        for (var $key2 in $dict1) {
            var selectionDictionaryEntry = { key: $key2, value: $dict1[$key2] };
            var selection = selectionDictionaryEntry.value;
            if (selection.IsActive) {
                var eachWayReduction = null;
                var eachWayPlaceTerms = null;
                if (forceEachWay && selection.EachWayReduction.length > 0) {
                    eachWayReduction = selection.EachWayReduction[0];
                    eachWayPlaceTerms = selection.EachWayPlaceTerms[0];
                }
                if (!forceEachWay && selection.ActiveEachWay >= 0) {
                    eachWayReduction = selection.EachWayReduction[selection.ActiveEachWay];
                    eachWayPlaceTerms = selection.EachWayPlaceTerms[selection.ActiveEachWay];
                }
                result.add(new FixedOddsBettingService.BetLeg(selection.Handicap, selection.UpperBand, selection.LowerBand, (!String.isNullOrEmpty(forcedIDFOPriceType)) ? forcedIDFOPriceType : selection.IDFOPriceType[selection.ActivePriceType], selection.IDFOSelection, selection.PriceDown, selection.PriceUp, eachWayReduction, eachWayPlaceTerms, selection.IsTrap, systemTag, interrelationTag, selection.IDFOEventScorecast));
                if (selection.IDFOEventScorecast) {
                    result.add(new FixedOddsBettingService.BetLeg(selection.Handicap, selection.UpperBand, selection.LowerBand, selection.IDFOPriceType[selection.ActivePriceType], selection.IDFOSelectionCS, selection.PriceDownCS, selection.PriceUpCS, eachWayReduction, eachWayPlaceTerms, selection.IsTrap, systemTag, interrelationTag, selection.IDFOEventScorecast));
                }
            }
        }
        return result;
    },
    
    _recalculateAllowedBetTypesAndReturns$1: function BetSlipService_BetSlipService$_recalculateAllowedBetTypesAndReturns$1() {
        if (!this._selections$1 || !Object.getKeyCount(this._selections$1)) {
            this._allowedBetTypes$1 = [];
            this._stakePerBetType$1 = {};
            this._stakePerSelection$1 = {};
            this._betSlipCalculation$1 = new FixedOddsBettingService.PotentialReturn();
            this._potentialReturns$1 = new FixedOddsBettingService.PotentialReturn();
            this._isEachWayPerBetType$1 = {};
            this._fireAllowedBetTypesChangedEvent$1();
            this._fireBetSlipCalculationChangedEvent$1();
        }
        else {
            this._recalculateAllowedBetTypesAndReturnsSequence$1++;
            var recalculateAllowedBetTypesAndReturnsSequence = this._recalculateAllowedBetTypesAndReturnsSequence$1;
            var betLegs = this._forceFixedOddsPrice$1(this._getBetLegs$1(true, null));
            this._environment.invokeAsync('FixedOddsBettingService', 'GetAllowedBetTypesAndReturns', { bet: new FixedOddsBettingService.BetInbound(betLegs, null, null, null, false, null, null, null), isEWPerBetType: this._isEachWayPerBetType$1 }, Delegate.create(this, function(result) {
                if (recalculateAllowedBetTypesAndReturnsSequence === this._recalculateAllowedBetTypesAndReturnsSequence$1) {
                    var betTypesAndReturns = result;
                    this._allowedBetTypes$1 = betTypesAndReturns.AllowedBetTypes;
                    this._potentialReturns$1 = betTypesAndReturns.PotentialReturns;
                    var betTypesToRemove = [];
                    var $dict1 = this._stakePerBetType$1;
                    for (var $key2 in $dict1) {
                        var stakePerBetTypeEntry = { key: $key2, value: $dict1[$key2] };
                        var clearStake = true;
                        for (var i = 0; i < this._allowedBetTypes$1.length; i++) {
                            if (this._allowedBetTypes$1[i].IDFOBetType === stakePerBetTypeEntry.key) {
                                clearStake = false;
                                if (Object.keyExists(this._isEachWayPerBetType$1, stakePerBetTypeEntry.key) && (this._isEachWayPerBetType$1[stakePerBetTypeEntry.key]) && !this._allowedBetTypes$1[i].IsEachWayAllowed) {
                                    delete this._isEachWayPerBetType$1[stakePerBetTypeEntry.key];
                                }
                                break;
                            }
                        }
                        if (clearStake) {
                            betTypesToRemove.add(stakePerBetTypeEntry.key);
                        }
                    }
                    for (var i = 0; i < betTypesToRemove.length; i++) {
                        delete this._stakePerBetType$1[betTypesToRemove[i]];
                        delete this._isEachWayPerBetType$1[betTypesToRemove[i]];
                    }
                    this._fireAllowedBetTypesChangedEvent$1();
					this._recalculateAllBetTypeReturns$1();
                    this._recalculateBetSlip$1();
                }
            }), Delegate.create(this, function(exception) {
                BetSlipService.BetSlipService._log$1.debug('RecalculateAllowedBetTypesAndReturns Cannot recalculate allowed bet types');
            }));
        }
    },
    
    _updateBetSlipSelections$1: function BetSlipService_BetSlipService$_updateBetSlipSelections$1() {
        if (Object.getKeyCount(this._selections$1) && !this._betSlipUpdateInProgress$1) {
            this._betSlipUpdateInProgress$1 = true;
            var selections = new Array(Object.getKeyCount(this._selections$1));
            var index = 0;
            var $dict1 = this._selections$1;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                selections[index++] = entry.value;
            }
            this._environment.invokeAsync('FixedOddsBettingService', 'UpdateBetSlipSelections', { selections: selections }, Delegate.create(this, function(result) {
                this._betSlipUpdateInProgress$1 = false;
                if (result) {
                    var updatedSelections = result;
                    if (updatedSelections.length > 0) {
                        for (var i = 0; i < updatedSelections.length; i++) {
                            var selectionKey = this.getSelectionKey(updatedSelections[i]);
                            if (updatedSelections[i].IDFOSelection === (this._selections$1[selectionKey]).IDFOSelection) {
                                var updatedSelection = null;
                                if (!updatedSelections[i].IDFOEventScorecast) {
                                    updatedSelection = FixedOddsBettingService.Selection.createSelection(updatedSelections[i].IDFOPriceType, updatedSelections[i].ActivePriceType, updatedSelections[i].IDFOEvent, updatedSelections[i].EventName, updatedSelections[i].IDFOMarket, updatedSelections[i].MarketName, updatedSelections[i].MTag, updatedSelections[i].TTagLeft, updatedSelections[i].TTagRight, updatedSelections[i].CTag, updatedSelections[i].IsTrapBettingOptionOn, updatedSelections[i].HADValue, updatedSelections[i].Handicap, updatedSelections[i].UpperBand, updatedSelections[i].LowerBand, updatedSelections[i].EachWayReduction, updatedSelections[i].EachWayPlaceTerms, updatedSelections[i].IDFOSelection, updatedSelections[i].SelectionName, updatedSelections[i].PriceUp, updatedSelections[i].PriceDown, updatedSelections[i].ActiveBetTypes, updatedSelections[i].FixedOddsPriceTypes, updatedSelections[i].SelectionHashCode, updatedSelections[i].IsTradable);
                                }
                                else {
                                    updatedSelection = FixedOddsBettingService.Selection.createScorecastSelection(updatedSelections[i].IDFOPriceType, updatedSelections[i].IDFOEvent, updatedSelections[i].EventName, updatedSelections[i].IDFOMarket, updatedSelections[i].MarketName, updatedSelections[i].MTag, updatedSelections[i].TTagLeft, updatedSelections[i].TTagRight, updatedSelections[i].CTag, updatedSelections[i].IDFOSelection, updatedSelections[i].SelectionName, updatedSelections[i].PriceUp, updatedSelections[i].PriceDown, updatedSelections[i].IDFOEventScorecast, updatedSelections[i].IDFOMarketCS, updatedSelections[i].MarketNameCS, updatedSelections[i].IDFOSelectionCS, updatedSelections[i].SelectionNameCS, updatedSelections[i].PriceUpCS, updatedSelections[i].PriceDownCS, updatedSelections[i].SelectionHashCode, updatedSelections[i].IsTradable);
                                }
                                this._previousSelections$1[selectionKey] = this._selections$1[selectionKey];
                                this._selections$1[selectionKey] = updatedSelection;
                            }
                        }
                        this._recalculateInterrelation$1();
                        this._recalculateAllowedBetTypesAndReturns$1();
                        this._fireBetSlipSelectionsUpdateEvent$1();
                    }
                }
            }), Delegate.create(this, function(ex) {
                BetSlipService.BetSlipService._log$1.debug('UpdateBetSlipSelections error');
            }));
        }
    },
    
    _recalculateBetSlip$1: function BetSlipService_BetSlipService$_recalculateBetSlip$1() {
        var betSlipInbound = this._getBetSlipInbound$1();
        if (!betSlipInbound.Bets.length) {
            this._betSlipCalculation$1 = new FixedOddsBettingService.PotentialReturn();
            this._fireBetSlipCalculationChangedEvent$1();
        }
        else {
            var adjustedResult = new FixedOddsBettingService.PotentialReturn();
            var hasSP = false;
            var $dict1 = this._selections$1;
            for (var $key2 in $dict1) {
                var selection = { key: $key2, value: $dict1[$key2] };
                var thisSelection = selection.value;
                if (thisSelection.IDFOPriceType[thisSelection.ActivePriceType] === 'SP') {
                    hasSP = true;
                    break;
                }
            }
            for (var i = 0; i < betSlipInbound.Bets.length; i++) {
                var betReturn = 1;
                var unitCount = 1;
                var isEachWay = (betSlipInbound.Bets[i].PlaceStake && betSlipInbound.Bets[i].PlaceStake > 0) ? true : false;
                var selectionKey = '';
                if (betSlipInbound.Bets[i].IDFOBetType === 'S' && i < Object.getKeyCount(this._stakePerSelection$1)) {
                    selectionKey = (betSlipInbound.Bets[i].BetLegs[0].IDFOPriceType === 'SC') ? this.getScorecastSelectionKey(betSlipInbound.Bets[i].BetLegs[0].IDFOEventScorecast, betSlipInbound.Bets[i].BetLegs[0].IDFOSelection, betSlipInbound.Bets[i].BetLegs[1].IDFOSelection) : this.getSimpleSelectionKey(betSlipInbound.Bets[i].BetLegs[0].IDFOSelection);
                    if (Object.keyExists(this._potentialReturns$1.PerSelection, selectionKey)) {
                        var currentSelection = this._selections$1[selectionKey];
                        var currentCalculatedBet = this._potentialReturns$1.PerSelection[selectionKey];
                        unitCount = currentCalculatedBet.UnitCount;
                        if (currentSelection.IDFOPriceType[currentSelection.ActivePriceType] === 'SP') {
                            betReturn = -1;
                        }
                        else {
                            betReturn = currentCalculatedBet.PotentialReturn;
                        }
                        if (isEachWay) {
                            unitCount *= 2;
                            if (currentSelection.IDFOPriceType[currentSelection.ActivePriceType] !== 'SP') {
                                betReturn += ((currentCalculatedBet.PotentialReturn - 1) / currentSelection.EachWayReduction[currentSelection.ActiveEachWay]) + 1;
                            }
                        }
                        if (currentSelection.IDFOPriceType[currentSelection.ActivePriceType] !== 'SP') {
                            betReturn = betSlipInbound.Bets[i].WinStake * betReturn;
                        }
                    }
                    else {
                        betReturn = -2;
                    }
                }
                else {
                    if (Object.keyExists(this._potentialReturns$1.PerBetType, betSlipInbound.Bets[i].IDFOBetType)) {
                        var currentCalculatedBet = this._potentialReturns$1.PerBetType[betSlipInbound.Bets[i].IDFOBetType];
                        betReturn = -1;
                        if (!hasSP) {
                            betReturn = betSlipInbound.Bets[i].WinStake * currentCalculatedBet.PotentialReturn;
                        }
                        unitCount = currentCalculatedBet.UnitCount;
                        if (isEachWay) {
                            unitCount *= 2;
                        }
                    }
                    else {
                        betReturn = -2;
                    }
                }
                var calcBet = new FixedOddsBettingService.CalculatedBet(betReturn, betSlipInbound.Bets[i].WinStake * unitCount, unitCount, betSlipInbound.Bets[i].IDFOBetType);
                if (!String.isNullOrEmpty(selectionKey)) {
                    adjustedResult.PerSelection[selectionKey] = calcBet;
                }
                else {
                    adjustedResult.PerBetType[betSlipInbound.Bets[i].IDFOBetType] = calcBet;
                }
            }
            adjustedResult = (betSlipInbound.IsFree) ? FixedOddsBettingService.FixedOddsBettingService.adjustBetSlipCalculationsForFreeBet(adjustedResult, betSlipInbound.IsFree) : adjustedResult;
            this._betSlipCalculation$1 = adjustedResult;
            this._fireBetSlipCalculationChangedEvent$1();
        }
    },
    
	_recalculateAllBetTypeReturns$1: function BetSlipService_BetSlipService$_recalculateAllBetTypeReturns$1() {
        var $dict1 = this._stakePerBetType$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            this._recalculateReturnForBetType$1(entry.key, (Object.keyExists(this._isEachWayPerBetType$1, entry.key)) ? this._isEachWayPerBetType$1[entry.key] : false);
        }
    },
	
    _recalculateReturnForBetType$1: function BetSlipService_BetSlipService$_recalculateReturnForBetType$1(IDFOBetType, isEachWay) {
        var betLegs = this._forceFixedOddsPrice$1(this._getBetLegs$1(true, null));
        this._environment.invokeAsyncSingle('FixedOddsBettingService', 'GetReturnForBetType', { bet: new FixedOddsBettingService.BetInbound(betLegs, IDFOBetType, null, null, false, 1, (isEachWay) ? 1 : 0, null) }, Delegate.create(this, function(result) {
            this._potentialReturns$1.PerBetType[IDFOBetType] = result;
            this._recalculateBetSlip$1();
        }), Delegate.create(this, function(exception) {
            BetSlipService.BetSlipService._log$1.debug('RecalculateReturnForBetType Cannot recalculate potential return');
        }));
    },
    
    _getKey$1: function BetSlipService_BetSlipService$_getKey$1(IDFOSelection1, IDFOSelection2) {
        return String.format('{0}{1}{2}', IDFOSelection1, BetSlipService.BetSlipService._keySeparator$1, IDFOSelection2);
    },
    
    _getLeft$1: function BetSlipService_BetSlipService$_getLeft$1(key) {
        return key.split(BetSlipService.BetSlipService._keySeparator$1)[0];
    },
    
    _getRight$1: function BetSlipService_BetSlipService$_getRight$1(key) {
        return key.split(BetSlipService.BetSlipService._keySeparator$1)[1];
    },
    
    _compareTags$1: function BetSlipService_BetSlipService$_compareTags$1(event1, market1, mtag1, ttagLeft1, ttagRight1, ctag1, event2, market2, mtag2, ttagLeft2, ttagRight2, ctag2) {
        if (market1 === market2) {
            return 0;
        }
        else if (event1 === event2 && this._compareTag$1(mtag1, mtag2)) {
            return 1;
        }
        else if (event1 !== event2 && (this._compareTag$1(ttagLeft1, ttagRight2) || this._compareTag$1(ttagRight1, ttagLeft2))) {
            return 2;
        }
        else if (event1 !== event2 && this._compareTag$1(ctag1, ctag2)) {
            return 3;
        }
        return -1;
    },
    
    _compareTag$1: function BetSlipService_BetSlipService$_compareTag$1(tag1, tag2) {
        if (String.isNullOrEmpty(tag1) || String.isNullOrEmpty(tag2)) {
            return false;
        }
        var ttagSeparator1 = tag1.indexOf(':');
        var ttagSeparator2 = tag2.indexOf(':');
        if (ttagSeparator1 >= 0 && ttagSeparator2 >= 0) {
            var parts1 = tag1.split(':');
            var parts2 = tag2.split(':');
            if (parts1.length >= 2 && parts2.length >= 2) {
                var comps1 = parts1[0].split('|');
                var comps2 = parts2[0].split('|');
                for (var i = 0; i < comps1.length; i++) {
                    for (var j = 0; j < comps2.length; j++) {
                        if (comps1[i] === comps2[j]) {
                            var deps1 = parts1[1].split(',');
                            var deps2 = parts2[1].split(',');
                            for (var m = 0; m < deps1.length; m++) {
                                for (var n = 0; n < deps2.length; n++) {
                                    if (deps1[m] === '*' || deps2[n] === '*' || deps1[m] === deps2[n]) {
                                        return true;
                                    }
                                }
                            }
                            return false;
                        }
                    }
                }
            }
            return false;
        }
        else if (ttagSeparator1 < 0 && ttagSeparator2 < 0) {
            var tags1 = tag1.split('!');
            var tags2 = tag2.split('!');
            for (var i = 0; i < tags1.length; i++) {
                var parts1 = tags1[i].split('|');
                for (var j = 0; j < tags2.length; j++) {
                    var parts2 = tags2[j].split('|');
                    if (parts1[0] === parts2[0] && parts1.length >= 2 && parts2.length >= 2) {
                        var deps1 = parts1[1].split(',');
                        var deps2 = parts2[1].split(',');
                        for (var m = 0; m < deps1.length; m++) {
                            for (var n = 0; n < deps2.length; n++) {
                                if (deps1[m] === '*' || deps2[n] === '*' || deps1[m] === deps2[n]) {
                                    return true;
                                }
                            }
                        }
                    }
                }
            }
            return false;
        }
        else {
            throw new Error(String.format('Incompatible tags {0} & {1}', tag1, tag2));
        }
    },
    
    _forceFixedOddsPrice$1: function BetSlipService_BetSlipService$_forceFixedOddsPrice$1(betLegs) {
        var $enum1 = betLegs.getEnumerator();
        while ($enum1.moveNext()) {
            var leg = $enum1.get_current();
            if (!leg.IDFOEventScorecast) {
                var thisSelection = this._selections$1[leg.IDFOSelection.toString()];
                if (thisSelection.FixedOddsPriceTypes && thisSelection.FixedOddsPriceTypes.length > 0) {
                    leg.IDFOPriceType = thisSelection.FixedOddsPriceTypes[0];
                }
            }
        }
        return betLegs;
    },
    
    _startBetSlipLiveUpdateTimer$1: function BetSlipService_BetSlipService$_startBetSlipLiveUpdateTimer$1() {
        this._clearBetSlipLiveUpdateTimeout$1();
        this._currentTimeout$1 = window.setTimeout(Delegate.create(this, function() {
            this._updateBetSlipSelections$1();
            this._startBetSlipLiveUpdateTimer$1();
        }), this._liveUpdatePeriod$1);
    },
    
    _clearBetSlipLiveUpdateTimeout$1: function BetSlipService_BetSlipService$_clearBetSlipLiveUpdateTimeout$1() {
        if (this._currentTimeout$1 !== -1) {
            window.clearTimeout(this._currentTimeout$1);
        }
    },
    
    getSimpleSelectionKey: function BetSlipService_BetSlipService$getSimpleSelectionKey(IDFOSelection) {
        return IDFOSelection.toString();
    },
    
    getScorecastSelectionKey: function BetSlipService_BetSlipService$getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
        return String.format('{0}-{1}-{2}', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
    },
    
    getSelectionKey: function BetSlipService_BetSlipService$getSelectionKey(selection) {
        return (!selection.IDFOEventScorecast) ? this.getSimpleSelectionKey(selection.IDFOSelection) : this.getScorecastSelectionKey(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS);
    },
    
    _getScorecastLegKey1GS$1: function BetSlipService_BetSlipService$_getScorecastLegKey1GS$1(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
        return this.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
    },
    
    _getScorecastLegKeyCS$1: function BetSlipService_BetSlipService$_getScorecastLegKeyCS$1(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
        return String.format('CS-{0}-{1}-{2}', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
    },
    
    checkIfBetSlipHasStake: function BetSlipService_BetSlipService$checkIfBetSlipHasStake() {
        var $dict1 = this._stakePerSelection$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (entry.value && entry.value) {
                return true;
            }
        }
        var $dict3 = this._stakePerBetType$1;
        for (var $key4 in $dict3) {
            var entry = { key: $key4, value: $dict3[$key4] };
            if (entry.value && entry.value) {
                return true;
            }
        }
        return false;
    },
    
    checkIfBetSlipHasCalculation: function BetSlipService_BetSlipService$checkIfBetSlipHasCalculation() {
        if (Object.getKeyCount(this._betSlipCalculation$1.PerBetType) || Object.getKeyCount(this._betSlipCalculation$1.PerSelection)) {
            return true;
        }
        else {
            return false;
        }
    },
    
    setRetainSelectionsAfterPlacement: function BetSlipService_BetSlipService$setRetainSelectionsAfterPlacement(retainSelectionsAfterPlacement) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetRetainSelectionsAfterPlacement retainSelectionsAfterPlacement=[{0}]', retainSelectionsAfterPlacement));
        this._retainSelectionsAfterPlacement$1 = retainSelectionsAfterPlacement;
        this._fireBetSlipCalculationChangedEvent$1();
    },
    
    setIsFree: function BetSlipService_BetSlipService$setIsFree(isFree) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetIsFree isFree=[{0}]', isFree));
        this._isFree$1 = isFree;
        this._recalculateBetSlip$1();
    },
    
    addSelection: function BetSlipService_BetSlipService$addSelection(IDFOPriceType, activePriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, isTrapBettingOptionOn, HADValue, handicap, upperBand, lowerBand, eachWayReduction, eachWayPlaceTerms, IDFOSelection, selectionName, priceUp, priceDown, activeBetTypes, fixedOddsPriceTypes, selectionHashCode, isTradable) {
        BetSlipService.BetSlipService._log$1.debug(String.format('AddSelection IDFOPriceType=[{0}] activePriceType=[{1}] IDFOEvent=[{2}] eventName=[{3}] IDFOMarket=[{4}] marketName=[{5}] MTag=[{6}] TTagLeft=[{7}] TTagRight=[{8}] CTag=[{9}] handicap=[{10}] upperBand=[{11}] lowerBand=[{12}] eachWayReduction=[{13}] eachWayPlaceTerms=[{14}] IDFOSelection=[{15}] selectionName=[{16}] priceUp=[{17}] priceDown=[{18}] activeBetTypes=[{19}] fixedOddsPriceTypes=[{20}]', IDFOPriceType, activePriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, handicap, upperBand, lowerBand, eachWayReduction, eachWayPlaceTerms, IDFOSelection, selectionName, priceUp, priceDown, activeBetTypes, fixedOddsPriceTypes));
        var selection = FixedOddsBettingService.Selection.createSelection(IDFOPriceType, activePriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, isTrapBettingOptionOn, HADValue, handicap, upperBand, lowerBand, eachWayReduction, eachWayPlaceTerms, IDFOSelection, selectionName, priceUp, priceDown, activeBetTypes, fixedOddsPriceTypes, selectionHashCode, isTradable);
        this._selections$1[this.getSimpleSelectionKey(IDFOSelection)] = selection;
        this._recalculateInterrelation$1();
        this._recalculateAllowedBetTypesAndReturns$1();
        this._fireSelectionsAddedEvent$1([ selection ]);
    },
    
    addScorecastSelection: function BetSlipService_BetSlipService$addScorecastSelection(IDFOPriceType, IDFOEvent, eventName, IDFOMarket1GS, marketName1GS, MTag, TTagLeft, TTagRight, CTag, IDFOSelection1GS, selectionName1GS, priceUp1GS, priceDown1GS, IDFOEventScorecast, IDFOMarketCS, marketNameCS, IDFOSelectionCS, selectionNameCS, priceUpCS, priceDownCS, selectionHashCode, isTradable) {
        BetSlipService.BetSlipService._log$1.debug(String.format('AddScorecastSelection IDFOPriceType=[{0}] IDFOEvent=[{1}] eventName=[{2}] IDFOMarket1GS=[{3}] marketName1GS=[{4}] MTag=[{5}] TTagLeft=[{6}] TTagRight=[{7}] CTag=[{8}] IDFOSelection1GS=[{9}] selectionName1GS=[{10}] priceUp1GS=[{11}] priceDown1GS=[{12}] IDFOEventScorecast=[{13}] IDFOMarketCS=[{14}] marketNameCS=[{15}] IDFOSelectionCS=[{16}] selectionNameCS=[{17}] priceUpCS=[{18}] priceDownCS=[{19}]', IDFOPriceType, IDFOEvent, eventName, IDFOMarket1GS, marketName1GS, MTag, TTagLeft, TTagRight, CTag, IDFOSelection1GS, selectionName1GS, priceUp1GS, priceDown1GS, IDFOEventScorecast, IDFOMarketCS, marketNameCS, IDFOSelectionCS, selectionNameCS, priceUpCS, priceDownCS));
        var selection = FixedOddsBettingService.Selection.createScorecastSelection(IDFOPriceType, IDFOEvent, eventName, IDFOMarket1GS, marketName1GS, MTag, TTagLeft, TTagRight, CTag, IDFOSelection1GS, selectionNameCS + '/' + selectionName1GS, priceUp1GS, priceDown1GS, IDFOEventScorecast, IDFOMarketCS, marketNameCS, IDFOSelectionCS, selectionNameCS, priceUpCS, priceDownCS, selectionHashCode, isTradable);
        selection.ActiveBetTypes = 'S';
        this._selections$1[this.getScorecastSelectionKey(selection.IDFOEventScorecast, selection.IDFOSelection, selection.IDFOSelectionCS)] = selection;
        this._recalculateInterrelation$1();
        this._recalculateAllowedBetTypesAndReturns$1();
        this._fireSelectionsAddedEvent$1([ selection ]);
    },
    
    removeSelection: function BetSlipService_BetSlipService$removeSelection(IDFOSelection) {
        BetSlipService.BetSlipService._log$1.debug(String.format('RemoveSelection IDFOSelection=[{0}]', IDFOSelection));
        var selectionKey = this.getSimpleSelectionKey(IDFOSelection);
        if (Object.keyExists(this._selections$1, selectionKey)) {
            var selection = this._selections$1[selectionKey];
            delete this._selections$1[selectionKey];
            delete this._previousSelections$1[selectionKey];
            delete this._stakePerSelection$1[selectionKey];
            this._recalculateInterrelation$1();
            this._recalculateAllowedBetTypesAndReturns$1();
            this._fireSelectionsRemovedEvent$1([ selection ]);
        }
    },
    
    removeScorecastSelection: function BetSlipService_BetSlipService$removeScorecastSelection(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS) {
        BetSlipService.BetSlipService._log$1.debug(String.format('RemoveScorecastSelection IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS));
        var selectionKey = this.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
        if (Object.keyExists(this._selections$1, selectionKey)) {
            var selection = this._selections$1[selectionKey];
            delete this._selections$1[selectionKey];
            delete this._previousSelections$1[selectionKey];
            delete this._stakePerSelection$1[selectionKey];
            this._recalculateInterrelation$1();
            this._recalculateAllowedBetTypesAndReturns$1();
            this._fireSelectionsRemovedEvent$1([ selection ]);
        }
    },
    
    removeAllSelections: function BetSlipService_BetSlipService$removeAllSelections() {
        BetSlipService.BetSlipService._log$1.debug('RemoveAllSelections');
        var selections = new Array(Object.getKeyCount(this._selections$1));
        var i = 0;
        var $dict1 = this._selections$1;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            selections[i++] = entry.value;
        }
        this._selections$1 = {};
        this._stakePerBetType$1 = {};
        this._stakePerSelection$1 = {};
        this._betSlipCalculation$1 = new FixedOddsBettingService.PotentialReturn();
        this._recalculateInterrelation$1();
        this._recalculateAllowedBetTypesAndReturns$1();
        this._fireSelectionsRemovedEvent$1(selections);
    },
    
    setSimpleSelectionActivity: function BetSlipService_BetSlipService$setSimpleSelectionActivity(IDFOSelection, isActive) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetSimpleSelectionActivity IDFOSelection=[{0}] isActive=[{1}]', IDFOSelection, isActive));
        var selection = this._selections$1[this.getSimpleSelectionKey(IDFOSelection)];
        selection.IsActive = isActive;
        this._recalculateInterrelation$1();
        this._recalculateAllowedBetTypesAndReturns$1();
    },
    
    setScorecastSelectionActivity: function BetSlipService_BetSlipService$setScorecastSelectionActivity(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, isActive) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetScorecastSelectionActivity IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}] isActive=[{3}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, isActive));
        var selection = this._selections$1[this.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS)];
        selection.IsActive = isActive;
        this._recalculateInterrelation$1();
        this._recalculateAllowedBetTypesAndReturns$1();
    },
    
    setSimpleSelectionIsTrap: function BetSlipService_BetSlipService$setSimpleSelectionIsTrap(IDFOSelection, isTrap) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetSimpleSelectionIsTrap IDFOSelection=[{0}] isTrap=[{1}]', IDFOSelection, isTrap));
        var selection = this._selections$1[this.getSimpleSelectionKey(IDFOSelection)];
        selection.IsTrap = isTrap;
    },
    
    setSimpleSelectionPriceType: function BetSlipService_BetSlipService$setSimpleSelectionPriceType(IDFOSelection, activePriceType) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetSimpleSelectionPriceType IDFOSelection=[{0}] activePriceType=[{1}]', IDFOSelection, activePriceType));
        var selection = this._selections$1[this.getSimpleSelectionKey(IDFOSelection)];
        selection.ActivePriceType = activePriceType;
        this._recalculateBetSlip$1();
    },
    
    setScorecastSelectionPriceType: function BetSlipService_BetSlipService$setScorecastSelectionPriceType(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, activePriceType) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetScorecastSelectionPriceType IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}] isActive=[{3}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, activePriceType));
        var selection = this._selections$1[this.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS)];
        selection.ActivePriceType = activePriceType;
        this._recalculateBetSlip$1();
    },
    
    setSimpleSelectionEachWay: function BetSlipService_BetSlipService$setSimpleSelectionEachWay(IDFOSelection, activeEachWay) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetSimpleSelectionEachWay IDFOSelection=[{0}] activeEachWay=[{1}]', IDFOSelection, activeEachWay));
        var selection = this._selections$1[this.getSimpleSelectionKey(IDFOSelection)];
        selection.ActiveEachWay = activeEachWay;
        this._recalculateBetSlip$1();
    },
    
    clearStakes: function BetSlipService_BetSlipService$clearStakes() {
        BetSlipService.BetSlipService._log$1.debug('ClearStakes');
        this._stakePerBetType$1 = {};
        this._stakePerSelection$1 = {};
        this._recalculateBetSlip$1();
    },
    
    setIsEachWayPerBetType: function BetSlipService_BetSlipService$setIsEachWayPerBetType(IDFOBetType, isEachWay) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetIsEachWayPerBetType IDFOBetType=[{0}] isEachWay=[{1}]', IDFOBetType, isEachWay));
        this._isEachWayPerBetType$1[IDFOBetType] = isEachWay;
        this._recalculateReturnForBetType$1(IDFOBetType, isEachWay);
    },
    
    setStakePerBetType: function BetSlipService_BetSlipService$setStakePerBetType(IDFOBetType, stake, deleteAllPrevious) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetStakePerBetType IDFOBetType=[{0}] stake=[{1}] deleteAllPrevious=[{2}]', IDFOBetType, stake, deleteAllPrevious));
        if (deleteAllPrevious) {
            this._stakePerBetType$1 = {};
        }
        if (isNaN(stake) || !stake) {
            stake = null;
        }
        if (!IDFOBetType && this._allowedBetTypes$1.length > 0) {
            IDFOBetType = this._allowedBetTypes$1[0].IDFOBetType;
        }
        if (stake && IDFOBetType) {
            this._stakePerBetType$1[IDFOBetType] = stake;
        }
        else if (!stake && IDFOBetType) {
            delete this._stakePerBetType$1[IDFOBetType];
        }
        if (Object.keyExists(this._potentialReturns$1.PerBetType, IDFOBetType)) {
            this._recalculateBetSlip$1();
        }
        else {
            this._recalculateReturnForBetType$1(IDFOBetType, (Object.keyExists(this._isEachWayPerBetType$1, IDFOBetType)) ? this._isEachWayPerBetType$1[IDFOBetType] : false);
        }
    },
    
    setStakePerSelection: function BetSlipService_BetSlipService$setStakePerSelection(IDFOSelection, winStake) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetStakePerSelection IDFOSelection=[{0}] winStake=[{1}]', IDFOSelection, winStake));
        var selectionKey = this.getSimpleSelectionKey(IDFOSelection);
        if (!winStake || isNaN(winStake) || !winStake) {
            delete this._stakePerSelection$1[selectionKey];
        }
        else {
            this._stakePerSelection$1[selectionKey] = winStake;
        }
        this._recalculateBetSlip$1();
    },
    
    setStakePerScorecastSelection: function BetSlipService_BetSlipService$setStakePerScorecastSelection(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, winStake) {
        BetSlipService.BetSlipService._log$1.debug(String.format('SetStakePerScorecastSelection IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}] winStake=[{3}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, winStake));
        var selectionKey = this.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
        if (!winStake || isNaN(winStake)) {
            delete this._stakePerSelection$1[selectionKey];
        }
        else {
            this._stakePerSelection$1[selectionKey] = winStake;
        }
        this._recalculateBetSlip$1();
    },
    
    changeBetSlipLiveUpdateTimerStatus: function BetSlipService_BetSlipService$changeBetSlipLiveUpdateTimerStatus(enableTimer) {
        if (!this._betSlipLiveUpdate$1) {
            return;
        }
        else if (enableTimer && this._currentTimeout$1 === -1) {
            this._startBetSlipLiveUpdateTimer$1();
        }
        else if (!enableTimer && this._currentTimeout$1 !== -1) {
            this._clearBetSlipLiveUpdateTimeout$1();
            this._currentTimeout$1 = -1;
        }
    },
    
    _recalculateInterrelation$1: function BetSlipService_BetSlipService$_recalculateInterrelation$1() {
        var graph = {};
        var $dict1 = this._selections$1;
        for (var $key2 in $dict1) {
            var entry1 = { key: $key2, value: $dict1[$key2] };
            var selection1 = entry1.value;
            var IDFOSelection1 = selection1.IDFOSelection;
            var $dict3 = this._selections$1;
            for (var $key4 in $dict3) {
                var entry2 = { key: $key4, value: $dict3[$key4] };
                var selection2 = entry2.value;
                var IDFOSelection2 = selection2.IDFOSelection;
                if (IDFOSelection1 >= IDFOSelection2) {
                    continue;
                }
                var ir = this._compareTags$1(selection1.IDFOEvent, selection1.IDFOMarket, selection1.MTag, selection1.TTagLeft, selection1.TTagRight, selection1.CTag, selection2.IDFOEvent, selection2.IDFOMarket, selection2.MTag, selection2.TTagLeft, selection2.TTagRight, selection2.CTag);
                if (ir >= 0) {
                    graph[this._getKey$1(IDFOSelection1, IDFOSelection2)] = graph[this._getKey$1(IDFOSelection2, IDFOSelection1)] = ir;
                }
            }
        }
        var color = 1;
        var result = {};
        var $dict5 = graph;
        for (var $key6 in $dict5) {
            var entry = { key: $key6, value: $dict5[$key6] };
            var IDFOSelection1 = this._getLeft$1(entry.key);
            var IDFOSelection2 = this._getRight$1(entry.key);
            if (Object.keyExists(result, IDFOSelection1)) {
                result[IDFOSelection2] = result[IDFOSelection1];
            }
            else if (Object.keyExists(result, IDFOSelection2)) {
                result[IDFOSelection1] = result[IDFOSelection2];
            }
            else {
                result[IDFOSelection1] = result[IDFOSelection2] = color++;
            }
        }
        this._selectionsInterRelationColors$1 = result;
    },
    
    isSelectionIn: function BetSlipService_BetSlipService$isSelectionIn(IDFOSelection, IDFOEventScorecast, IDFOSelectionCS) {
        var isIn = false;
        var $dict1 = this._selections$1;
        for (var $key2 in $dict1) {
            var singleSelection = { key: $key2, value: $dict1[$key2] };
            var selection = singleSelection.value;
            if (!selection.IDFOEventScorecast) {
                isIn = (selection.IDFOSelection === IDFOSelection);
                if (isIn) {
                    break;
                }
            }
            else {
                isIn = (selection.IDFOEventScorecast === IDFOEventScorecast && selection.IDFOSelection === IDFOSelection && selection.IDFOSelectionCS === IDFOSelectionCS);
                if (isIn) {
                    break;
                }
            }
        }
        return isIn;
    },
    
    placeBetSlip: function BetSlipService_BetSlipService$placeBetSlip(isBetConfirmationScreenShownBeforePlacementOverride) {
        BetSlipService.BetSlipService._log$1.debug('PlaceBetSlip');
        var sentSelections = {};
        if (Object.getKeyCount(this._stakePerBetType$1) > 0) {
            var $dict1 = this._selections$1;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                sentSelections[entry.key] = entry.value;
            }
        }
        else {
            var $dict3 = this._stakePerSelection$1;
            for (var $key4 in $dict3) {
                var entry = { key: $key4, value: $dict3[$key4] };
                sentSelections[entry.key] = this._selections$1[entry.key];
            }
        }
        var calculatedBet = [];
        var $dict5 = this._selections$1;
        for (var $key6 in $dict5) {
            var singleSelection = { key: $key6, value: $dict5[$key6] };
            if (Object.keyExists(this._stakePerSelection$1, singleSelection.key)) {
                calculatedBet.add(this._betSlipCalculation$1.PerSelection[singleSelection.key]);
            }
        }
        var $dict7 = this._stakePerBetType$1;
        for (var $key8 in $dict7) {
            var stakePerBetTypeEntry = { key: $key8, value: $dict7[$key8] };
            calculatedBet.add(this._betSlipCalculation$1.PerBetType[stakePerBetTypeEntry.key]);
        }
        this._fixedOddsBettingService$1.placeBetSlip(sentSelections, calculatedBet, this._getBetSlipInbound$1(), isBetConfirmationScreenShownBeforePlacementOverride);
    }
}


////////////////////////////////////////////////////////////////////////////////
// BetSlipService.OverridingPriceTypes

BetSlipService.OverridingPriceTypes = function BetSlipService_OverridingPriceTypes() {
}


BetSlipService.BetSlipService.createClass('BetSlipService.BetSlipService', Framework.AbstractService, Framework.IPageWillChangeListener, FixedOddsBettingService.IBetPlacementStateChangedListener);
BetSlipService.OverridingPriceTypes.createClass('BetSlipService.OverridingPriceTypes');
BetSlipService.BetSlipService._serviceName$1 = 'BetSlipService';
BetSlipService.BetSlipService._log$1 = Framework.Logger.getLog(BetSlipService.BetSlipService._serviceName$1);
BetSlipService.BetSlipService._keySeparator$1 = ':';
BetSlipService.OverridingPriceTypes.priceTypeOverrides = { SFC: 'FCD', RFC: 'FCD', CFC: 'FCD', SFC2: 'FCD', RFC2: 'FCD', CFC2: 'FCD', SFC3: 'FCD', RFC3: 'FCD', CFC3: 'FCD', SFCP: 'FCD', RFCP: 'FCD', SFCY: 'FCD', RFCY: 'FCD', SFCL15: 'FCD', RFCL15: 'FCD', EX: 'EPD', REX: 'EPD', CEX: 'EPD', QU: 'QPD', CQU: 'QPD', STC: 'TCD', CTC: 'TCD', STF: 'TPD', CTF: 'TPD' };

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('RacePoolBetSlipService');

////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener

RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener = function() { };
RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener.prototype = {
    onRacePoolBetSlipCalculationChanged : null
}
RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener.createInterface('RacePoolBetSlipService.IRacePoolBetSlipCalculationChangedListener');


////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.IRacePoolSelectionsRemovedListener

RacePoolBetSlipService.IRacePoolSelectionsRemovedListener = function() { };
RacePoolBetSlipService.IRacePoolSelectionsRemovedListener.prototype = {
    onRacePoolSelectionsRemoved : null
}
RacePoolBetSlipService.IRacePoolSelectionsRemovedListener.createInterface('RacePoolBetSlipService.IRacePoolSelectionsRemovedListener');


////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.IRacePoolSelectionsAddedListener

RacePoolBetSlipService.IRacePoolSelectionsAddedListener = function() { };
RacePoolBetSlipService.IRacePoolSelectionsAddedListener.prototype = {
    onRacePoolSelectionsAdded : null
}
RacePoolBetSlipService.IRacePoolSelectionsAddedListener.createInterface('RacePoolBetSlipService.IRacePoolSelectionsAddedListener');


////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.RacePool

RacePoolBetSlipService.RacePool = function RacePoolBetSlipService_RacePool(IDFOMarket, IDFOPriceType, racePoolTab, minNoSelections) {
    this.idfoMarket = IDFOMarket;
    this.idfoPriceType = IDFOPriceType;
    this.racePoolTab = racePoolTab;
    this.minNoSelections = minNoSelections;
    this.selections = {};
    this.selectionsPlaces = {};
    this.isAnyOrderRacePool = false;
}
RacePoolBetSlipService.RacePool.prototype = {
    idfoMarket: null,
    idfoPriceType: null,
    priceTypeName: null,
    idfoBetType: null,
    betTypeName: null,
    racePoolTab: null,
    minNoSelections: null,
    selectionsPlaces: null,
    selections: null,
    unitStake: null,
    calculatedBet: null,
    unscaledCalculatedBet: null,
    isAnyOrderRacePool: false
}


////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.RacePoolBetSlipService

RacePoolBetSlipService.RacePoolBetSlipService = function RacePoolBetSlipService_RacePoolBetSlipService() {
    this._racePoolRaceTabsManagers$1 = {};
    this._racePools$1 = {};
    this._racePoolBetSlipCalculationChangedListeners$1 = new Framework.ListenerInvoker(true);
    this._racePoolSelectionsAddedListeners$1 = new Framework.ListenerInvoker(true);
    this._racePoolSelectionsRemovedListeners$1 = new Framework.ListenerInvoker(true);
    RacePoolBetSlipService.RacePoolBetSlipService.constructBase(this);
}
RacePoolBetSlipService.RacePoolBetSlipService.prototype = {
    
    onPageWillChange: function RacePoolBetSlipService_RacePoolBetSlipService$onPageWillChange() {
        this._environment.storeState(RacePoolBetSlipService.RacePoolBetSlipService._serviceName$1, this._getState$1());
    },
    
    _fixedOddsBettingService$1: null,
    
    setFixedOddsBettingService: function RacePoolBetSlipService_RacePoolBetSlipService$setFixedOddsBettingService(fixedOddsBettingService) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('SetFixedOddsBettingService');
        this._fixedOddsBettingService$1 = fixedOddsBettingService;
    },
    
    _userService$1: null,
    
    setUserService: function RacePoolBetSlipService_RacePoolBetSlipService$setUserService(userService) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('SetUserService');
        this._userService$1 = userService;
    },
    
    init: function RacePoolBetSlipService_RacePoolBetSlipService$init(environment, parameters) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        RacePoolBetSlipService.RacePoolBetSlipService.callBase(this, 'init', [ environment, parameters ]);
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(RacePoolBetSlipService.RacePoolBetSlipService._serviceName$1);
        if (state) {
            this._setState$1(state);
        }
    },
    
    start: function RacePoolBetSlipService_RacePoolBetSlipService$start() {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('Start');
    },
    
    registerRacePoolBetSlipCalculationChangedListener: function RacePoolBetSlipService_RacePoolBetSlipService$registerRacePoolBetSlipCalculationChangedListener(betSlipCalculationChangedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('RegisterRacePoolBetSlipCalculationChangedListener');
        this._racePoolBetSlipCalculationChangedListeners$1.registerListener(betSlipCalculationChangedListener);
    },
    
    unregisterRacePoolBetSlipCalculationChangedListener: function RacePoolBetSlipService_RacePoolBetSlipService$unregisterRacePoolBetSlipCalculationChangedListener(betSlipCalculationChangedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('UnregisterRacePoolBetSlipCalculationChangedListener');
        this._racePoolBetSlipCalculationChangedListeners$1.unregisterListener(betSlipCalculationChangedListener);
    },
    
    _fireRacePoolBetSlipCalculationChangedEvent$1: function RacePoolBetSlipService_RacePoolBetSlipService$_fireRacePoolBetSlipCalculationChangedEvent$1(IDFOMarket, IDFOPriceType) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('FireRacePoolBetSlipCalculationChangedEvent');
        this._racePoolBetSlipCalculationChangedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onRacePoolBetSlipCalculationChanged(IDFOMarket, IDFOPriceType);
        }));
    },
    
    registerRacePoolSelectionsAddedListener: function RacePoolBetSlipService_RacePoolBetSlipService$registerRacePoolSelectionsAddedListener(selectionAddedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('RegisterRacePoolSelectionsAddedListener');
        this._racePoolSelectionsAddedListeners$1.registerListener(selectionAddedListener);
    },
    
    unregisterRacePoolSelectionsAddedListener: function RacePoolBetSlipService_RacePoolBetSlipService$unregisterRacePoolSelectionsAddedListener(selectionAddedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('UnregisterRacePoolSelectionsAddedListener');
        this._racePoolSelectionsAddedListeners$1.unregisterListener(selectionAddedListener);
    },
    
    _fireRacePoolSelectionsAddedEvent$1: function RacePoolBetSlipService_RacePoolBetSlipService$_fireRacePoolSelectionsAddedEvent$1(IDFOMarket, selection, selectionsPlaces) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('FireRacePoolSelectionsAddedEvent');
        this._racePoolSelectionsAddedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onRacePoolSelectionsAdded(IDFOMarket, selection, selectionsPlaces);
        }));
    },
    
    registerRacePoolSelectionsRemovedListener: function RacePoolBetSlipService_RacePoolBetSlipService$registerRacePoolSelectionsRemovedListener(selectionRemovedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('RegisterRacePoolSelectionsRemovedListener');
        this._racePoolSelectionsRemovedListeners$1.registerListener(selectionRemovedListener);
    },
    
    unregisterRacePoolSelectionsRemovedListener: function RacePoolBetSlipService_RacePoolBetSlipService$unregisterRacePoolSelectionsRemovedListener(selectionRemovedListener) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('UnregisterRacePoolSelectionsRemovedListener');
        this._racePoolSelectionsRemovedListeners$1.unregisterListener(selectionRemovedListener);
    },
    
    _fireRacePoolSelectionRemovedEvent$1: function RacePoolBetSlipService_RacePoolBetSlipService$_fireRacePoolSelectionRemovedEvent$1(IDFOMarket, selection, selectionsPlaces) {
        RacePoolBetSlipService.RacePoolBetSlipService._log$1.debug('FireRacePoolSelectionsRemovedEvent');
        this._racePoolSelectionsRemovedListeners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onRacePoolSelectionsRemoved(IDFOMarket, selection, selectionsPlaces);
        }));
    },
    
    getRacePool: function RacePoolBetSlipService_RacePoolBetSlipService$getRacePool(IDFOMarket, IDFOPriceType) {
        var racePoolKey = this._getRacePoolKey$1(IDFOMarket, IDFOPriceType);
        if (Object.keyExists(this._racePools$1, racePoolKey)) {
            return this._racePools$1[racePoolKey];
        }
        else {
            return null;
        }
    },
    
    getRacePools: function RacePoolBetSlipService_RacePoolBetSlipService$getRacePools() {
        return this._racePools$1;
    },
    
    getRacePoolRaceTabsManager: function RacePoolBetSlipService_RacePoolBetSlipService$getRacePoolRaceTabsManager(IDFOMarket) {
        return this._racePoolRaceTabsManagers$1[this._getRacePoolRaceTabsManagerKey$1(IDFOMarket)];
    },
    
    getRacePoolRaceTabsManagers: function RacePoolBetSlipService_RacePoolBetSlipService$getRacePoolRaceTabsManagers() {
        return this._racePoolRaceTabsManagers$1;
    },
    
    setRacePoolActiveTab: function RacePoolBetSlipService_RacePoolBetSlipService$setRacePoolActiveTab(IDFOMarket, racePoolTab) {
        if (Object.keyExists(this._racePoolRaceTabsManagers$1, this._getRacePoolRaceTabsManagerKey$1(IDFOMarket))) {
            (this._racePoolRaceTabsManagers$1[this._getRacePoolRaceTabsManagerKey$1(IDFOMarket)]).activeRacePoolTab = racePoolTab;
        }
    },
    
    addRacePoolSelection: function RacePoolBetSlipService_RacePoolBetSlipService$addRacePoolSelection(IDFOMarket, IDFOPriceType, racePoolTab, selectionPlace, minNoSelections, IDFOEvent, eventName, marketName, MTag, TTagLeft, TTagRight, CTag, IDFOSelection, selectionName) {
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        if (!racePool) {
            racePool = new RacePoolBetSlipService.RacePool(IDFOMarket, IDFOPriceType, racePoolTab, minNoSelections);
            if ((selectionPlace.toLowerCase() === 'any') && (racePool.idfoPriceType.toUpperCase() === 'FCD')) {
                racePool.betTypeName = 'Reverse Forecast';
            }
            else if ((selectionPlace.toLowerCase() === 'any') && (racePool.idfoPriceType.toUpperCase() === 'TCD')) {
                racePool.betTypeName = 'Combination Tricast';
            }
            else if ((selectionPlace.toLowerCase() !== 'any') && (racePool.idfoPriceType.toUpperCase() === 'FCD')) {
                racePool.betTypeName = 'Forecast';
            }
            else if ((selectionPlace.toLowerCase() !== 'any') && (racePool.idfoPriceType.toUpperCase() === 'TCD')) {
                racePool.betTypeName = 'Tricast';
            }
            this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)] = racePool;
        }
        if (selectionPlace !== RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1 && Object.keyExists(racePool.selectionsPlaces, selectionPlace)) {
            this.removeRacePoolSelection(IDFOMarket, IDFOPriceType, Number.parse((racePool.selectionsPlaces[selectionPlace])[0].toString()), selectionPlace);
        }
        var selection = FixedOddsBettingService.Selection.createRacePoolSelection(IDFOPriceType, IDFOEvent, eventName, IDFOMarket, marketName, MTag, TTagLeft, TTagRight, CTag, IDFOSelection, selectionName);
        racePool.selections[this._getRacePoolSelectionKey$1(IDFOSelection)] = selection;
        this._addSelection$1(racePool, selectionPlace, IDFOSelection);
        this._fireRacePoolSelectionsAddedEvent$1(IDFOMarket, [ selection ], [ selectionPlace ]);
        if (selectionPlace === RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1) {
            racePool.isAnyOrderRacePool = true;
        }
        else {
            racePool.isAnyOrderRacePool = false;
        }
        var removedSelections = [];
        var removedSelectionPlaces = [];
        var $dict1 = racePool.selectionsPlaces;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var currentSelectionPlace = entry.key;
            if ((racePool.isAnyOrderRacePool && currentSelectionPlace !== RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1) || (!racePool.isAnyOrderRacePool && currentSelectionPlace === RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1)) {
                var IDFOSelections = entry.value;
                for (var i = 0; i < IDFOSelections.length; i++) {
                    removedSelections.add(racePool.selections[this._getRacePoolSelectionKey$1(Number.parse(IDFOSelections[i].toString()))]);
                    removedSelectionPlaces.add(currentSelectionPlace);
                }
            }
        }
        if (removedSelections.length > 0) {
            this._removeRacePoolSelections$1(IDFOMarket, IDFOPriceType, removedSelections, removedSelectionPlaces);
        }
        else {
            this._recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, 'selection');
        }
    },
    
    removeRacePoolSelection: function RacePoolBetSlipService_RacePoolBetSlipService$removeRacePoolSelection(IDFOMarket, IDFOPriceType, IDFOSelection, sectionPlace) {
        if (this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)] && Object.keyExists((this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)]).selections, this._getRacePoolSelectionKey$1(IDFOSelection))) {
            this._removeRacePoolSelections$1(IDFOMarket, IDFOPriceType, [ (this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)]).selections[this._getRacePoolSelectionKey$1(IDFOSelection)] ], [ sectionPlace ]);
        }
    },
    
    checkRacePoolSelections: function RacePoolBetSlipService_RacePoolBetSlipService$checkRacePoolSelections(IDFOMarket, IDFOPriceType) {
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        if (!racePool) {
            return 'skip';
        }
        else if (!this._racePoolHasValidSelections$1(racePool)) {
            return 'Please complete making your selections for ' + this._getRacePoolName$1(racePool) + ' (or clear its form if you don\'t want to place it)';
        }
        else if (!this._racePoolHasStake$1(racePool)) {
            return 'Please enter a stake greater than zero for ' + this._getRacePoolName$1(racePool) + ' (or clear its form if you don\'t want to place it)';
        }
        else {
            return '';
        }
    },
    
    placeRacePoolBetSlip: function RacePoolBetSlipService_RacePoolBetSlipService$placeRacePoolBetSlip(IDFOMarket, IDFOPriceTypes) {
        var calculatedBets = [];
        var selections = {};
        var racePools = [];
        var $enum1 = IDFOPriceTypes.getEnumerator();
        while ($enum1.moveNext()) {
            var priceType = $enum1.get_current();
            var racePool = this.getRacePool(IDFOMarket, priceType);
            calculatedBets.add(racePool.calculatedBet);
            racePools.add(racePool);
            var $dict2 = racePool.selections;
            for (var $key3 in $dict2) {
                var entry = { key: $key3, value: $dict2[$key3] };
                if (!Object.keyExists(selections, entry.key)) {
                    selections[entry.key] = entry.value;
                }
            }
        }
        this._fixedOddsBettingService$1.placeBetSlip(selections, calculatedBets, this._getBetSlipInbound$1(racePools), FixedOddsBettingService.OverrideToShowConfirmation.notOverride);
        var $enum4 = IDFOPriceTypes.getEnumerator();
        while ($enum4.moveNext()) {
            var priceType = $enum4.get_current();
            this.removeAllRacePoolSelections(IDFOMarket, priceType);
        }
    },
    
    setRacePoolStake: function RacePoolBetSlipService_RacePoolBetSlipService$setRacePoolStake(IDFOMarket, IDFOPriceType, racePoolTab, minNoSelections, unitStake, racePoolName) {
        var racePool = this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)];
        if (!racePool) {
            racePool = new RacePoolBetSlipService.RacePool(IDFOMarket, IDFOPriceType, racePoolTab, minNoSelections);
            this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)] = racePool;
        }
        racePool.unitStake = unitStake;
        this._recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, 'stake');
    },
    
    addTabToRacePoolRaceTabsManager: function RacePoolBetSlipService_RacePoolBetSlipService$addTabToRacePoolRaceTabsManager(IDFOMarket, racePoolTab) {
        var key = this._getRacePoolRaceTabsManagerKey$1(IDFOMarket);
        if (!Object.keyExists(this._racePoolRaceTabsManagers$1, key)) {
            this._racePoolRaceTabsManagers$1[key] = new RacePoolBetSlipService.RacePoolRaceTabsManager(IDFOMarket);
        }
        if (!(this._racePoolRaceTabsManagers$1[key]).racePoolTabs.contains(racePoolTab)) {
            (this._racePoolRaceTabsManagers$1[key]).racePoolTabs.add(racePoolTab);
        }
    },
    
    removeAllRacePoolSelections: function RacePoolBetSlipService_RacePoolBetSlipService$removeAllRacePoolSelections(IDFOMarket, IDFOPriceType) {
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        var selections = [];
        var selectionsPlaces = [];
        var $dict1 = racePool.selectionsPlaces;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var currentSelectionPlace = entry.key;
            if (racePool.selectionsPlaces[currentSelectionPlace]) {
                var currentIDFOSelections = racePool.selectionsPlaces[currentSelectionPlace];
                for (var i = 0; i < currentIDFOSelections.length; i++) {
                    selections.add(racePool.selections[currentIDFOSelections[i].toString()]);
                    selectionsPlaces.add(currentSelectionPlace);
                }
            }
        }
        delete this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)];
        this._fireRacePoolSelectionRemovedEvent$1(IDFOMarket, selections, selectionsPlaces);
    },
    
    _getRacePoolKey$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolKey$1(IDFOMarket, IDFOPriceType) {
        return String.format('{0}-{1}', IDFOMarket, IDFOPriceType);
    },
    
    _getRacePoolRaceTabsManagerKey$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolRaceTabsManagerKey$1(IDFOMarket) {
        return IDFOMarket.toString();
    },
    
    _getRacePoolSelectionKey$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolSelectionKey$1(IDFOSelection) {
        return IDFOSelection.toString();
    },
    
    _addSelection$1: function RacePoolBetSlipService_RacePoolBetSlipService$_addSelection$1(racePool, selectionPlace, IDFOSelection) {
        if (!Object.keyExists(racePool.selectionsPlaces, selectionPlace) || !racePool.selectionsPlaces[selectionPlace]) {
            racePool.selectionsPlaces[selectionPlace] = [];
        }
        var selectionsPlaces = racePool.selectionsPlaces[selectionPlace];
        if (!selectionsPlaces.contains(IDFOSelection)) {
            selectionsPlaces.add(IDFOSelection);
        }
    },
    
    _removeSelection$1: function RacePoolBetSlipService_RacePoolBetSlipService$_removeSelection$1(racePool, selectionPlace, IDFOSelection) {
        if (Object.keyExists(racePool.selectionsPlaces, selectionPlace)) {
            var selectionsPlaces = racePool.selectionsPlaces[selectionPlace];
            if (selectionsPlaces && selectionsPlaces.contains(IDFOSelection)) {
                selectionsPlaces.remove(IDFOSelection);
                if (!selectionsPlaces.length) {
                    delete racePool.selectionsPlaces[selectionPlace];
                }
            }
        }
    },
    
    _getRacePoolBetLegs$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolBetLegs$1(racePool) {
        var betLegs = [];
        var $dict1 = racePool.selectionsPlaces;
        for (var $key2 in $dict1) {
            var placeEntry = { key: $key2, value: $dict1[$key2] };
            var currentSelectionPlace = placeEntry.key;
            var IDFOSelections = placeEntry.value;
            if (IDFOSelections) {
                for (var i = 0; i < IDFOSelections.length; i++) {
                    var selection = racePool.selections[IDFOSelections[i].toString()];
                    var currentBetLeg = new FixedOddsBettingService.BetLeg(selection.Handicap, selection.UpperBand, selection.LowerBand, selection.IDFOPriceType[selection.ActivePriceType], selection.IDFOSelection, selection.PriceDown, selection.PriceUp, null, null, false, null, null, selection.IDFOEventScorecast);
                    if (currentSelectionPlace === RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1) {
                        betLegs.add(currentBetLeg);
                    }
                    else {
                        betLegs[Number.parse(currentSelectionPlace)] = currentBetLeg;
                    }
                }
            }
        }
        return betLegs;
    },
    
    _getBetSlipInbound$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getBetSlipInbound$1(racePools) {
        var bets = [];
        var $enum1 = racePools.getEnumerator();
        while ($enum1.moveNext()) {
            var racePool = $enum1.get_current();
            var betLegs = this._getRacePoolBetLegs$1(racePool);
            racePool.idfoBetType = this._getRacePoolBetType$1(racePool);
            bets.add(new FixedOddsBettingService.BetInbound(betLegs, racePool.idfoBetType, racePool.betTypeName, null, false, racePool.unitStake, null, null));
        }
        return new FixedOddsBettingService.BetSlipInbound(false, bets);
    },
    
    _recalculateRacePoolBetReturn$1: function RacePoolBetSlipService_RacePoolBetSlipService$_recalculateRacePoolBetReturn$1(IDFOMarket, IDFOPriceType) {
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        if (!Object.getKeyCount(racePool.selections) && !this._racePoolHasStake$1(racePool)) {
            delete this._racePools$1[this._getRacePoolKey$1(IDFOMarket, IDFOPriceType)];
        }
        else if (this._racePoolHasValidSelections$1(racePool) && this._racePoolHasStake$1(racePool)) {
            var betSlipInbound = this._getBetSlipInbound$1([ racePool ]);
            this._environment.invokeAsync('FixedOddsBettingService', 'CalculateBetSlip', { betSlip: betSlipInbound }, Delegate.create(this, function(result) {
                var returnedCalculation = result;
                for (var i = 0; i < betSlipInbound.Bets.length; i++) {
                    returnedCalculation[i].IDFOBetType = betSlipInbound.Bets[i].IDFOBetType;
                }
                if (returnedCalculation[0]) {
                    racePool.unscaledCalculatedBet = returnedCalculation[0];
                }
                else {
                    racePool.unscaledCalculatedBet = null;
                    racePool.calculatedBet = null;
                    racePool.idfoBetType = '';
                }
                this._recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, 'recalculation');
            }), Delegate.create(this, function(exception) {
                if (racePool.unscaledCalculatedBet || racePool.calculatedBet) {
                    racePool.unscaledCalculatedBet = null;
                    racePool.calculatedBet = null;
                    racePool.idfoBetType = '';
                    this._recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, 'recalculation');
                }
            }));
        }
    },
    
    _recalculateRacePoolBetSlip$1: function RacePoolBetSlipService_RacePoolBetSlipService$_recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, changeAgent) {
        var recalculate = false;
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        if (changeAgent === 'selection' && this._racePoolHasStake$1(racePool) && this._racePoolHasValidSelections$1(racePool)) {
            recalculate = true;
        }
        else if (changeAgent === 'recalculation') {
            recalculate = true;
        }
        else if (changeAgent === 'stake') {
            recalculate = true;
        }
        if ((!recalculate && changeAgent === 'selection') || (!racePool.unscaledCalculatedBet && changeAgent === 'recalculation')) {
            if (racePool.unscaledCalculatedBet || racePool.calculatedBet) {
                racePool.unscaledCalculatedBet = null;
                racePool.calculatedBet = null;
                racePool.idfoBetType = '';
                this._fireRacePoolBetSlipCalculationChangedEvent$1(IDFOMarket, IDFOPriceType);
            }
        }
        else {
            if ((!racePool.unscaledCalculatedBet && changeAgent !== 'recalculation') || (changeAgent === 'selection')) {
                this._recalculateRacePoolBetReturn$1(IDFOMarket, IDFOPriceType);
            }
            else {
                racePool.calculatedBet = new FixedOddsBettingService.CalculatedBet(racePool.unscaledCalculatedBet.PotentialReturn, racePool.unitStake * racePool.unscaledCalculatedBet.UnitCount, racePool.unscaledCalculatedBet.UnitCount, racePool.unscaledCalculatedBet.IDFOBetType);
                this._fireRacePoolBetSlipCalculationChangedEvent$1(IDFOMarket, IDFOPriceType);
            }
        }
    },
    
    _racePoolHasStake$1: function RacePoolBetSlipService_RacePoolBetSlipService$_racePoolHasStake$1(racePool) {
        return (racePool && racePool.unitStake) ? true : false;
    },
    
    _racePoolHasValidSelections$1: function RacePoolBetSlipService_RacePoolBetSlipService$_racePoolHasValidSelections$1(racePool) {
        return !String.isNullOrEmpty(this._getRacePoolBetType$1(racePool));
    },
    
    _getState$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getState$1() {
        return { racePools: this._racePools$1, racePoolRaceTabsManagers: this._racePoolRaceTabsManagers$1 };
    },
    
    _setState$1: function RacePoolBetSlipService_RacePoolBetSlipService$_setState$1(state) {
        this._racePools$1 = state['racePools'];
        this._racePoolRaceTabsManagers$1 = state['racePoolRaceTabsManagers'];
    },
    
    _removeRacePoolSelections$1: function RacePoolBetSlipService_RacePoolBetSlipService$_removeRacePoolSelections$1(IDFOMarket, IDFOPriceType, selections, selectionsPlaces) {
        var racePool = this.getRacePool(IDFOMarket, IDFOPriceType);
        var selectionsToCheck = [];
        if (racePool) {
            for (var i = 0; i < selections.length; i++) {
                this._removeSelection$1(racePool, selectionsPlaces[i], selections[i].IDFOSelection);
                selectionsToCheck.add(Number.parse(this._getRacePoolSelectionKey$1(selections[i].IDFOSelection)));
            }
            for (var i = 0; i < selectionsToCheck.length; i++) {
                var remove = true;
                var $dict1 = racePool.selectionsPlaces;
                for (var $key2 in $dict1) {
                    var selectionPlaceEntry = { key: $key2, value: $dict1[$key2] };
                    if (selectionPlaceEntry.value && (selectionPlaceEntry.value).contains(selectionsToCheck[i])) {
                        remove = false;
                    }
                }
                if (remove) {
                    delete racePool.selections[selectionsToCheck[i].toString()];
                }
            }
            this._fireRacePoolSelectionRemovedEvent$1(IDFOMarket, selections, selectionsPlaces);
            this._recalculateRacePoolBetSlip$1(IDFOMarket, IDFOPriceType, 'selection');
        }
    },
    
    _getRacePoolBetType$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolBetType$1(racePool) {
        var betLegs = 0;
        var $dict1 = racePool.selectionsPlaces;
        for (var $key2 in $dict1) {
            var selectionPlaceEntry = { key: $key2, value: $dict1[$key2] };
            if (selectionPlaceEntry.value && (selectionPlaceEntry.value).length > 0) {
                var IDFOSelections = (selectionPlaceEntry.value);
                betLegs += IDFOSelections.length;
            }
        }
        var isAnyBet = racePool.isAnyOrderRacePool;
        var IDFOBetType = '';
        switch (racePool.idfoPriceType) {
            case 'FCD':
                switch (betLegs) {
                    case 0:
                    case 1:
                        break;
                    case 2:
                        IDFOBetType = (isAnyBet) ? 'RFC' : 'SFC';
                        break;
                    default:
                        IDFOBetType = (isAnyBet) ? 'CFC' : '';
                        break;
                }
                break;
            case 'EPD':
                switch (betLegs) {
                    case 0:
                    case 1:
                        break;
                    case 2:
                        IDFOBetType = (isAnyBet) ? 'REX' : 'EX';
                        break;
                    default:
                        IDFOBetType = (isAnyBet) ? 'CEX' : '';
                        break;
                }
                break;
            case 'QPD':
                switch (betLegs) {
                    case 0:
                    case 1:
                        break;
                    case 2:
                        IDFOBetType = (isAnyBet) ? 'QU' : 'QU';
                        break;
                    default:
                        IDFOBetType = (isAnyBet) ? 'CQU' : '';
                        break;
                }
                break;
            case 'TCD':
                switch (betLegs) {
                    case 0:
                    case 1:
                    case 2:
                        break;
                    case 3:
                        IDFOBetType = (isAnyBet) ? 'CTC' : 'STC';
                        break;
                    default:
                        IDFOBetType = (isAnyBet) ? 'CTC' : '';
                        break;
                }
                break;
            case 'TPD':
                switch (betLegs) {
                    case 0:
                    case 1:
                    case 2:
                        break;
                    case 3:
                        IDFOBetType = (isAnyBet) ? 'CTF' : 'STF';
                        break;
                    default:
                        IDFOBetType = (isAnyBet) ? 'CTF' : '';
                        break;
                }
                break;
        }
        return IDFOBetType;
    },
    
    _getRacePoolName$1: function RacePoolBetSlipService_RacePoolBetSlipService$_getRacePoolName$1(racePool) {
        var racePoolName = '';
        switch (racePool.idfoPriceType) {
            case 'FCD':
                racePoolName = 'Forecast';
                break;
            case 'TCD':
                racePoolName = 'Tricast';
                break;
            case 'EPD':
                racePoolName = 'Exacta';
                break;
            case 'TPD':
                racePoolName = 'Trifecta';
                break;
            case 'QPD':
                racePoolName = 'Quinella';
                break;
        }
        return racePoolName;
    }
}


////////////////////////////////////////////////////////////////////////////////
// RacePoolBetSlipService.RacePoolRaceTabsManager

RacePoolBetSlipService.RacePoolRaceTabsManager = function RacePoolBetSlipService_RacePoolRaceTabsManager(IDFOMarket) {
    this.idfoMarket = IDFOMarket;
    this.activeRacePoolTab = 'win';
    this.racePoolTabs = [];
}
RacePoolBetSlipService.RacePoolRaceTabsManager.prototype = {
    idfoMarket: null,
    racePoolTabs: null,
    activeRacePoolTab: null
}


RacePoolBetSlipService.RacePool.createClass('RacePoolBetSlipService.RacePool');
RacePoolBetSlipService.RacePoolBetSlipService.createClass('RacePoolBetSlipService.RacePoolBetSlipService', Framework.AbstractService, Framework.IPageWillChangeListener);
RacePoolBetSlipService.RacePoolRaceTabsManager.createClass('RacePoolBetSlipService.RacePoolRaceTabsManager');
RacePoolBetSlipService.RacePoolBetSlipService._serviceName$1 = 'RacePoolBetSlipService';
RacePoolBetSlipService.RacePoolBetSlipService._selectionPlaceAnyOrder$1 = 'any';
RacePoolBetSlipService.RacePoolBetSlipService._log$1 = Framework.Logger.getLog(RacePoolBetSlipService.RacePoolBetSlipService._serviceName$1);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('NumbersService');

////////////////////////////////////////////////////////////////////////////////
// NumbersService.IBetPlacementListener

NumbersService.IBetPlacementListener = function() { };
NumbersService.IBetPlacementListener.prototype = {
    onBetPlacementSuccess : null,
    onBetPlacementFailure : null,
    onConfirmationRequired : null,
    onRejected : null,
    onWaitingForResponse : null,
    onNotWaitingForResponse : null,
    onBetPreviewReady : null
}
NumbersService.IBetPlacementListener.createInterface('NumbersService.IBetPlacementListener');


////////////////////////////////////////////////////////////////////////////////
// NumbersService.IBetsChangedListener

NumbersService.IBetsChangedListener = function() { };
NumbersService.IBetsChangedListener.prototype = {
    onBetTotalsChanged : null
}
NumbersService.IBetsChangedListener.createInterface('NumbersService.IBetsChangedListener');


////////////////////////////////////////////////////////////////////////////////
// NumbersService.ICurrentBallsetChangedListener

NumbersService.ICurrentBallsetChangedListener = function() { };
NumbersService.ICurrentBallsetChangedListener.prototype = {
    onCurrentBallsetChanged : null,
    onCurrentBallsetBetsChanged : null
}
NumbersService.ICurrentBallsetChangedListener.createInterface('NumbersService.ICurrentBallsetChangedListener');


////////////////////////////////////////////////////////////////////////////////
// NumbersService.IDrawsChangedListener

NumbersService.IDrawsChangedListener = function() { };
NumbersService.IDrawsChangedListener.prototype = {
    onDrawsChanged : null,
    onMarketsChanged : null,
    onWeeksSubscribedChanged : null
}
NumbersService.IDrawsChangedListener.createInterface('NumbersService.IDrawsChangedListener');


////////////////////////////////////////////////////////////////////////////////
// NumbersService.ILotteryChangedListener

NumbersService.ILotteryChangedListener = function() { };
NumbersService.ILotteryChangedListener.prototype = {
    onLotteryChanged : null
}
NumbersService.ILotteryChangedListener.createInterface('NumbersService.ILotteryChangedListener');


////////////////////////////////////////////////////////////////////////////////
// NumbersService.INumbersChangedListener

NumbersService.INumbersChangedListener = function() { };
NumbersService.INumbersChangedListener.prototype = {
    onNumbersChanged : null
}
NumbersService.INumbersChangedListener.createInterface('NumbersService.INumbersChangedListener');


////////////////////////////////////////////////////////////////////////////////
// NumbersService.Ball

NumbersService.Ball = function NumbersService_Ball() {
}
NumbersService.Ball.prototype = {
    Number: 0
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.BallSet

NumbersService.BallSet = function NumbersService_BallSet() {
    this._balls = [];
}
NumbersService.BallSet.prototype = {
    
    _setBallSetState: function NumbersService_BallSet$_setBallSetState(state) {
        this.type = state.type;
        this.lineNumber = state.lineNumber;
        this.maxNumbersOfBalls = state.maxNumbersOfBalls;
        this._setBalls(state._balls);
        this.bets = state.bets;
    },
    
    addBall: function NumbersService_BallSet$addBall(newBall) {
        var found = null;
        var $enum1 = this._balls.getEnumerator();
        while ($enum1.moveNext()) {
            var ball = $enum1.get_current();
            if (ball.Number === newBall) {
                found = ball;
                break;
            }
        }
        if (!found) {
            if (this.maxNumbersOfBalls <= this._balls.length) {
                throw new Error('maxballexceeded|The maximum number of balls that can be picked is ' + this.maxNumbersOfBalls);
            }
            var newBallO = new NumbersService.Ball();
            newBallO.Number = newBall;
            this._balls.add(newBallO);
            this._setBetTypeCode();
        }
    },
    
    _calculateStraightBetTypeCode: function NumbersService_BallSet$_calculateStraightBetTypeCode() {
        switch (this._balls.length) {
            case 0:
                return '';
            case 1:
                return 'S';
            case 2:
                return 'D';
            case 3:
                return 'T';
            default:
                return 'A';
        }
    },
    
    removeBall: function NumbersService_BallSet$removeBall(oldBall) {
        var found = null;
        var $enum1 = this._balls.getEnumerator();
        while ($enum1.moveNext()) {
            var ball = $enum1.get_current();
            if (ball.Number === oldBall) {
                found = ball;
                break;
            }
        }
        if (found) {
            this._balls.remove(found);
            this._setBetTypeCode();
        }
    },
    
    getNumberOfBalls: function NumbersService_BallSet$getNumberOfBalls() {
        return this._balls.length;
    },
    
    getBalls: function NumbersService_BallSet$getBalls() {
        return this._balls;
    },
    
    _setBalls: function NumbersService_BallSet$_setBalls(balls) {
        this._balls = [];
        var $enum1 = balls.getEnumerator();
        while ($enum1.moveNext()) {
            var ball = $enum1.get_current();
            this._balls.add(ball);
        }
    },
    
    _setBetTypeCode: function NumbersService_BallSet$_setBetTypeCode() {
        if (this.type === NumbersService.NumbersService.linE_TYPE_STRAIGHTS) {
            var betTypeCode = this._calculateStraightBetTypeCode();
            if (this.bets[0].betTypeCode !== betTypeCode) {
                this.bets[0].betTypeCode = betTypeCode;
            }
        }
        if (!this._balls.length && this.bets) {
            var $enum1 = this.bets.getEnumerator();
            while ($enum1.moveNext()) {
                var bet = $enum1.get_current();
                bet.betTypeCode = '';
                bet.potentialReturn = 0;
                bet.stake = 0;
                bet.totalStake = 0;
                bet.unitCount = 0;
            }
        }
    },
    
    clear: function NumbersService_BallSet$clear() {
        this._balls = [];
        this._setBetTypeCode();
    },
    
    type: null,
    lineNumber: 0,
    maxNumbersOfBalls: 5,
    bets: null,
    
    isEqual: function NumbersService_BallSet$isEqual(ballSet) {
        if (!ballSet) {
            return false;
        }
        if (ballSet.lineNumber !== this.lineNumber) {
            return false;
        }
        if (ballSet.type !== this.type) {
            return false;
        }
        if (ballSet.maxNumbersOfBalls !== this.maxNumbersOfBalls) {
            return false;
        }
        return true;
    }
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService._ballSetState

NumbersService._ballSetState = function NumbersService__ballSetState() {
    this._balls = new Array(0);
    this.bets = new Array(0);
}
NumbersService._ballSetState.prototype = {
    type: '',
    lineNumber: 0,
    maxNumbersOfBalls: 0
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.Bet

NumbersService.Bet = function NumbersService_Bet() {
}
NumbersService.Bet.prototype = {
    betTypeCode: '',
    stake: 0,
    totalStake: 0,
    unitCount: 0,
    potentialReturn: 0
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.BetType

NumbersService.BetType = function NumbersService_BetType() {
}
NumbersService.BetType.prototype = {
    IDFOBetType: null,
    IsEachWayAllowed: false,
    Name: null
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.BettypeSeedValue

NumbersService.BettypeSeedValue = function NumbersService_BettypeSeedValue() {
}
NumbersService.BettypeSeedValue.prototype = {
    Bettype: null,
    SeedValue: null,
    TotalStake: null,
    UnitCount: 0,
    PotentialReturn: null
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.CalculatedLine

NumbersService.CalculatedLine = function NumbersService_CalculatedLine() {
}
NumbersService.CalculatedLine.prototype = {
    PotentialReturn: null,
    TotalStake: null,
    UnitCount: 0
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.ColumnCountSeedValue

NumbersService.ColumnCountSeedValue = function NumbersService_ColumnCountSeedValue() {
}
NumbersService.ColumnCountSeedValue.prototype = {
    ColumnCount: 0,
    BettypeSeedValues: null
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.DetailedTicketStates

NumbersService.DetailedTicketStates = function NumbersService_DetailedTicketStates() {
}
NumbersService.DetailedTicketStates.isSecurityCodeRequiredForTopup = function NumbersService_DetailedTicketStates$isSecurityCodeRequiredForTopup(ticketStatus) {
    return (ticketStatus.DetailedState & NumbersService.DetailedTicketStates.securityCodeRequiredForTopup);
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.LineInbound

NumbersService.LineInbound = function NumbersService_LineInbound() {
}
NumbersService.LineInbound.prototype = {
    Balls: null,
    IDFOBetType: null,
    IDFOMarket: null,
    IDFOPriceType: null,
    Stake: null
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.LineOutbound

NumbersService.LineOutbound = function NumbersService_LineOutbound() {
}
NumbersService.LineOutbound.prototype = {
    Balls: null,
    IDFOBetType: null,
    IDFOMarket: null,
    IDFOPriceType: null,
    Stake: null,
    ExternalReference: null,
    MaxTakeout: null,
    PotentialReturn: null,
    TotalStake: null,
    UnitCount: 0
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.NumbersService

NumbersService.NumbersService = function NumbersService_NumbersService() {
    this._state$1 = {};
    this._currentBallSetChangedListeners$1 = [];
    this._lotteryChangedListeners$1 = [];
    this._numbersAddedListeners$1 = [];
    this._betsChangedListeners$1 = [];
    this._drawsChangedListeners$1 = [];
    this._linesChangedListeners$1 = [];
    this._betPlacementListeners$1 = [];
    NumbersService.NumbersService.constructBase(this);
    NumbersService.NumbersService._log$1.debug('ctor');
}
NumbersService.NumbersService.prototype = {
    _weeksAhead$1: 1,
    _maxMultipleBalls$1: 0,
    _maxStraightLines$1: 0,
    _idfoSport$1: null,
    _lottoHomePageAction$1: 'lotto',
    _lottoBetPlacementPageAction$1: 'lotto-placement',
    
    get_lottoHomePageAction: function NumbersService_NumbersService$get_lottoHomePageAction() {
        return this._lottoHomePageAction$1;
    },
    
    get_lottoBetPlacementPageAction: function NumbersService_NumbersService$get_lottoBetPlacementPageAction() {
        return this._lottoBetPlacementPageAction$1;
    },
    
    get_weeksAhead: function NumbersService_NumbersService$get_weeksAhead() {
        return this._weeksAhead$1;
    },
    set_weeksAhead: function NumbersService_NumbersService$set_weeksAhead(value) {
        this._weeksAhead$1 = value;
        this._fireWeeksSubscribedEvent$1(this._weeksAhead$1);
        return value;
    },
    
    init: function NumbersService_NumbersService$init(environment, parameters) {
        NumbersService.NumbersService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        NumbersService.NumbersService.callBase(this, 'init', [ environment, parameters ]);
        try {
            this._maxMultipleBalls$1 = parameters['max-multiple-balls'];
        }
        catch ($e1) {
            this._maxMultipleBalls$1 = 8;
        }
        try {
            this._maxStraightLines$1 = parameters['max-straight-lines'];
        }
        catch ($e2) {
            this._maxStraightLines$1 = 8;
        }
        if (Object.keyExists(parameters, 'lottery-home-page-action')) {
            this._lottoHomePageAction$1 = parameters['lottery-home-page-action'];
        }
        if (Object.keyExists(parameters, 'lotto-bet-placement-page-action')) {
            this._lottoBetPlacementPageAction$1 = parameters['lotto-bet-placement-page-action'];
        }
        environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(NumbersService.NumbersService._serviceName$1);
        if (state) {
            this._setServiceState$1(state);
        }
    },
    
    start: function NumbersService_NumbersService$start() {
        NumbersService.NumbersService._log$1.debug('Start');
    },
    
    _accountService$1: null,
    
    setAccountService: function NumbersService_NumbersService$setAccountService(accountService) {
        NumbersService.NumbersService._log$1.debug('SetAccountService');
        this._accountService$1 = accountService;
    },
    
    _userService$1: null,
    
    setUserService: function NumbersService_NumbersService$setUserService(userService) {
        NumbersService.NumbersService._log$1.debug('SetUserService');
        this._userService$1 = userService;
    },
    
    _navigationService$1: null,
    
    setNavigationService: function NumbersService_NumbersService$setNavigationService(navigationService) {
        NumbersService.NumbersService._log$1.debug('SetNavigationService');
        this._navigationService$1 = navigationService;
    },
    
    _fixedOddsBettingService: null,
    
    setFixedOddsBettingService: function NumbersService_NumbersService$setFixedOddsBettingService(fixedOddsBettingService) {
        NumbersService.NumbersService._log$1.debug('SetFixedOddsBettingService');
        this._fixedOddsBettingService = fixedOddsBettingService;
    },
    
    _getServiceState$1: function NumbersService_NumbersService$_getServiceState$1() {
        return { state: this._state$1, idfoSport: this._idfoSport$1 };
    },
    
    _getCurrentLotteryState$1: function NumbersService_NumbersService$_getCurrentLotteryState$1() {
        var key = this.getLottery();
        if (!Object.keyExists(this._state$1, key)) {
            var state = new NumbersService.NumbersServiceState();
            state.idfOsport = key;
            this._state$1[key] = state;
        }
        return this._state$1[key];
    },
    
    _clearCurrentLotteryState$1: function NumbersService_NumbersService$_clearCurrentLotteryState$1() {
        var key = this.getLottery();
        var state;
        if (Object.keyExists(this._state$1, key)) {
            state = new NumbersService.NumbersServiceState();
            state.idfOsport = key;
            this._state$1[key] = state;
        }
        state = this._getCurrentLotteryState$1();
        this._fireDrawsChangedEvent$1(state.idfOlotterydrawpatterns, state.includeBonusBall);
        this._fireNumbersChangedEvent$1(this.getCurrentBallSet());
        this._fireBetsChangedEvent$1(this.getBetTotals());
        this._fireMarketsChangedEvent$1(this.getMarkets());
    },
    
    _setServiceState$1: function NumbersService_NumbersService$_setServiceState$1(state) {
        var rawSate = state['state'];
        var processedState = {};
        var $dict1 = rawSate;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            processedState[entry.key] = this._restoreState$1(rawSate[entry.key], entry.key);
        }
        this._state$1 = processedState;
        this._idfoSport$1 = state['idfoSport'];
        if (!this._state$1) {
            this._state$1 = {};
        }
    },
    
    _restoreState$1: function NumbersService_NumbersService$_restoreState$1(state, key) {
        if (!state) {
            state = new NumbersService.NumbersServiceState();
            state.idfOsport = key;
            return state;
        }
        var ballSets = state.ballSets;
        var restBallSets = {};
        if (state.ballSets) {
            var $dict1 = state.ballSets;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                var bs = new NumbersService.BallSet();
                bs._setBallSetState(entry.value);
                restBallSets[entry.key] = bs;
            }
            state.ballSets = restBallSets;
        }
        if (state.currentBallSet) {
            var bs = ((state.currentBallSet));
            this._setCurrentBallSetInner$1(state, bs.type, bs.lineNumber, bs.maxNumbersOfBalls);
        }
        return state;
    },
    
    _getBallSet$1: function NumbersService_NumbersService$_getBallSet$1(state, type, lineNumber) {
        var key = String.format('{0}|{1}', type, lineNumber);
        if (!Object.keyExists(state.ballSets, key)) {
            return null;
        }
        return state.ballSets[key];
    },
    
    _setBallSet$1: function NumbersService_NumbersService$_setBallSet$1(type, lineNumber, ballset) {
        var key = String.format('{0}|{1}', type, lineNumber);
        this._getCurrentLotteryState$1().ballSets[key] = ballset;
    },
    
    _setCurrentBallSetInner$1: function NumbersService_NumbersService$_setCurrentBallSetInner$1(state, type, lineNumber, maxNumberOfBalls) {
        var ballset = this._getBallSet$1(state, type, lineNumber);
        if (!ballset) {
            ballset = new NumbersService.BallSet();
            ballset.type = type;
            ballset.maxNumbersOfBalls = maxNumberOfBalls;
            ballset.lineNumber = lineNumber;
            if (type === NumbersService.NumbersService.linE_TYPE_STRAIGHTS) {
                var bet = new NumbersService.Bet();
                ballset.bets = [ bet ];
            }
            else {
                ballset.bets = [];
                for (var i = 0; i < maxNumberOfBalls; i++) {
                    ballset.bets[i] = new NumbersService.Bet();
                }
            }
            this._setBallSet$1(type, lineNumber, ballset);
        }
        state.currentBallSet = ballset;
    },
    
    _setDrawPatterns$1: function NumbersService_NumbersService$_setDrawPatterns$1(drawPatterns) {
        this._getCurrentLotteryState$1().idfOlotterydrawpatterns = (drawPatterns || new Array(0));
    },
    
    _setMarketsForDrawPattern$1: function NumbersService_NumbersService$_setMarketsForDrawPattern$1(idfoDrawPattern, markets) {
        this._getCurrentLotteryState$1().idfOlotterydrawpatternToMarket[idfoDrawPattern] = (markets || new Array(0));
    },
    
    _onGetSeedValuesComplete$1: function NumbersService_NumbersService$_onGetSeedValuesComplete$1(result) {
        this._getCurrentLotteryState$1().seedValues = result;
    },
    
    _getPriceTypeSeedValue$1: function NumbersService_NumbersService$_getPriceTypeSeedValue$1(ballset) {
        var state = this._getCurrentLotteryState$1();
        if (ballset && ballset.bets) {
            var priceType = this.getPriceType(state.includeBonusBall);
            if (ballset.type && state.seedValues && state.seedValues.PriceTypeSeedValues && Object.keyExists(state.seedValues.PriceTypeSeedValues, priceType)) {
                return state.seedValues.PriceTypeSeedValues[priceType];
            }
        }
        return null;
    },
    
    _getColumnCountSeedValue$1: function NumbersService_NumbersService$_getColumnCountSeedValue$1(ballset, betIndex) {
        var ptSeedValues = this._getPriceTypeSeedValue$1(ballset);
        if (ptSeedValues && ptSeedValues.ColumnCountSeedValues && Object.keyExists(ptSeedValues.ColumnCountSeedValues, betIndex.toString())) {
            return ptSeedValues.ColumnCountSeedValues[betIndex.toString()];
        }
        return null;
    },
    
    _recalculateBetTotals$1: function NumbersService_NumbersService$_recalculateBetTotals$1() {
        var state = this._getCurrentLotteryState$1();
        var totalBet = new NumbersService.Bet();
        var idfoMarkets = this.getMarkets();
        if (state.ballSets && idfoMarkets && idfoMarkets.length > 0) {
            var $dict1 = state.ballSets;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                var ballset = entry.value;
                var $enum3 = ballset.bets.getEnumerator();
                while ($enum3.moveNext()) {
                    var bet = $enum3.get_current();
                    if (bet.betTypeCode && bet.betTypeCode.trim().length > 0 && bet.stake && bet.stake > 0) {
                        totalBet.totalStake = totalBet.totalStake + bet.totalStake;
                        totalBet.unitCount = totalBet.unitCount + bet.unitCount;
                        totalBet.potentialReturn = totalBet.potentialReturn + bet.potentialReturn;
                    }
                }
            }
            var drawcount = idfoMarkets.length;
            totalBet.totalStake = totalBet.totalStake * drawcount;
            totalBet.unitCount = totalBet.unitCount * drawcount;
            totalBet.potentialReturn = totalBet.potentialReturn * drawcount;
        }
        state.betTotals = totalBet;
        this._fireBetsChangedEvent$1(totalBet);
    },
    
    _recalculateBets$1: function NumbersService_NumbersService$_recalculateBets$1(ballset, recalculateTotals) {
        for (var i = 0; i < ballset.bets.length; i++) {
            var colIndex = 0;
            if (ballset.type === NumbersService.NumbersService.linE_TYPE_STRAIGHTS) {
                colIndex = ballset.getNumberOfBalls();
            }
            else {
                colIndex = Math.min((i + 1), ballset.getNumberOfBalls());
            }
            var ccSeedValue = this._getColumnCountSeedValue$1(ballset, colIndex);
            if (ccSeedValue && ccSeedValue.BettypeSeedValues) {
                var bet = ballset.bets[i];
                if (bet && bet.betTypeCode && bet.betTypeCode.trim().length > 0 && Object.keyExists(ccSeedValue.BettypeSeedValues, bet.betTypeCode)) {
                    var btSeedValue = ccSeedValue.BettypeSeedValues[bet.betTypeCode];
                    if (btSeedValue) {
                        bet.potentialReturn = bet.stake * btSeedValue.PotentialReturn;
                        bet.unitCount = btSeedValue.UnitCount;
                        bet.totalStake = bet.stake * btSeedValue.TotalStake;
                    }
                }
                else {
                    bet.potentialReturn = 0;
                    bet.unitCount = 0;
                    bet.totalStake = 0;
                    if (ballset.type !== NumbersService.NumbersService.linE_TYPE_STRAIGHTS) {
                        bet.betTypeCode = '';
                    }
                }
            }
        }
        if (recalculateTotals) {
            this._recalculateBetTotals$1();
        }
    },
    
    _addMarketInt$1: function NumbersService_NumbersService$_addMarketInt$1(idfoMarket, idfoDrawPattern, fireEvent) {
        var markets = this.getMarketsForDrawPattern(idfoDrawPattern);
        if (!markets.contains(idfoMarket)) {
            var idfomarkets = new Array(markets.length + 1);
            for (var i = 0; i < markets.length; i++) {
                idfomarkets[i] = markets[i];
            }
            idfomarkets[idfomarkets.length - 1] = idfoMarket;
            this._setMarketsForDrawPattern$1(idfoDrawPattern, idfomarkets);
            if (fireEvent) {
                this._recalculateBetTotals$1();
                this._fireMarketsChangedEvent$1(this.getMarkets());
            }
        }
    },
    
    _removeMarketInt$1: function NumbersService_NumbersService$_removeMarketInt$1(idfoMarket, idfoDrawPattern, fireEvent) {
        var markets = this.getMarketsForDrawPattern(idfoDrawPattern);
        if (markets.contains(idfoMarket)) {
            var idfomarkets = new Array(markets.length - 1);
            var index = 0;
            for (var i = 0; i < markets.length; i++) {
                if (markets[i] !== idfoMarket) {
                    idfomarkets[index] = markets[i];
                    index++;
                }
            }
            this._setMarketsForDrawPattern$1(idfoDrawPattern, idfomarkets);
            if (fireEvent) {
                this._recalculateBetTotals$1();
                this._fireMarketsChangedEvent$1(this.getMarkets());
            }
        }
    },
    
    registerCurrentBallSetChangedListener: function NumbersService_NumbersService$registerCurrentBallSetChangedListener(ballSetChangedListener) {
        NumbersService.NumbersService._log$1.debug('RegisterCurrentBallSetChangedListener');
        if (!this._currentBallSetChangedListeners$1.contains(ballSetChangedListener)) {
            this._currentBallSetChangedListeners$1.add(ballSetChangedListener);
        }
    },
    
    registerLotteryChangedListener: function NumbersService_NumbersService$registerLotteryChangedListener(lotteryChangedListener) {
        NumbersService.NumbersService._log$1.debug('RegisterLotteryChangedListener');
        if (!this._lotteryChangedListeners$1.contains(lotteryChangedListener)) {
            this._lotteryChangedListeners$1.add(lotteryChangedListener);
        }
    },
    
    registerNumbersChangedListener: function NumbersService_NumbersService$registerNumbersChangedListener(numbersAddedListener) {
        NumbersService.NumbersService._log$1.debug('RegisterNumbersChangedListener');
        if (!this._numbersAddedListeners$1.contains(numbersAddedListener)) {
            this._numbersAddedListeners$1.add(numbersAddedListener);
        }
    },
    
    registerBetsChangedListener: function NumbersService_NumbersService$registerBetsChangedListener(betsChangedListener) {
        NumbersService.NumbersService._log$1.debug('RegisterBetsChangedListener');
        if (!this._betsChangedListeners$1.contains(betsChangedListener)) {
            this._betsChangedListeners$1.add(betsChangedListener);
        }
    },
    
    registerDrawsChangedListener: function NumbersService_NumbersService$registerDrawsChangedListener(drawsChangedListener) {
        NumbersService.NumbersService._log$1.debug('RegisterDrawsChangedListener');
        if (!this._drawsChangedListeners$1.contains(drawsChangedListener)) {
            this._drawsChangedListeners$1.add(drawsChangedListener);
        }
    },
    
    registerBetPlacementListener: function NumbersService_NumbersService$registerBetPlacementListener(betPlacementListener) {
        NumbersService.NumbersService._log$1.debug('RegisterBetPlacementListener');
        if (!this._betPlacementListeners$1.contains(betPlacementListener)) {
            this._betPlacementListeners$1.add(betPlacementListener);
        }
    },
    
    unregisterCurrentBallSetChangedListener: function NumbersService_NumbersService$unregisterCurrentBallSetChangedListener(ballSetChangedListener) {
        NumbersService.NumbersService._log$1.debug('UnregisterCurrentBallSetChangedListener');
        this._currentBallSetChangedListeners$1.remove(ballSetChangedListener);
    },
    
    unregisterLotteryChangedListener: function NumbersService_NumbersService$unregisterLotteryChangedListener(lotteryChangedListener) {
        NumbersService.NumbersService._log$1.debug('UnregisterLotteryChangedListener');
        this._lotteryChangedListeners$1.remove(lotteryChangedListener);
    },
    
    unregisterNumbersChangedListener: function NumbersService_NumbersService$unregisterNumbersChangedListener(numbersAddedListener) {
        NumbersService.NumbersService._log$1.debug('UnregisterNumbersChangedListener');
        this._numbersAddedListeners$1.remove(numbersAddedListener);
    },
    
    unregisterBetsChangedListener: function NumbersService_NumbersService$unregisterBetsChangedListener(betsChangedListener) {
        NumbersService.NumbersService._log$1.debug('UnregisterBetsChangedListener');
        this._betsChangedListeners$1.remove(betsChangedListener);
    },
    
    unregisterDrawsChangedListener: function NumbersService_NumbersService$unregisterDrawsChangedListener(drawsChangedListener) {
        NumbersService.NumbersService._log$1.debug('UnregisterDrawsChangedListener');
        this._drawsChangedListeners$1.remove(drawsChangedListener);
    },
    
    unregisterBetPlacementListener: function NumbersService_NumbersService$unregisterBetPlacementListener(betPlacementListener) {
        NumbersService.NumbersService._log$1.debug('UnregisterBetPlacementListener');
        this._betPlacementListeners$1.remove(betPlacementListener);
    },
    
    _fireCurrentBallSetChangedEvent$1: function NumbersService_NumbersService$_fireCurrentBallSetChangedEvent$1(ballSet) {
        NumbersService.NumbersService._log$1.debug('FireCurrentBallSetChangedEvent');
        var $enum1 = this._currentBallSetChangedListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onCurrentBallsetChanged(this, ballSet);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireCurrentBallSetChangedEvent OnLotteryChanged', e);
            }
        }
    },
    
    _fireCurrentBallSetBetsChangedEvent$1: function NumbersService_NumbersService$_fireCurrentBallSetBetsChangedEvent$1(ballSet) {
        NumbersService.NumbersService._log$1.debug('FireCurrentBallSetBetsChangedEvent');
        var $enum1 = this._currentBallSetChangedListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onCurrentBallsetBetsChanged(this, ballSet);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireCurrentBallSetBetsChangedEvent OnLotteryChanged', e);
            }
        }
    },
    
    _fireLotteryChangedEvent$1: function NumbersService_NumbersService$_fireLotteryChangedEvent$1(idfosport) {
        NumbersService.NumbersService._log$1.debug('FireLotteryChangedEvent');
        var $enum1 = this._lotteryChangedListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onLotteryChanged(this, idfosport);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireLotteryChangedEvent OnLotteryChanged', e);
            }
        }
    },
    
    _fireNumbersChangedEvent$1: function NumbersService_NumbersService$_fireNumbersChangedEvent$1(ballset) {
        NumbersService.NumbersService._log$1.debug('FireNumbersChangedEvent');
        var isCurrentBallSet = false;
        if (ballset) {
            isCurrentBallSet = ballset.isEqual(this._getCurrentLotteryState$1().currentBallSet);
        }
        var $enum1 = this._numbersAddedListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onNumbersChanged(this, ballset, isCurrentBallSet);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireNumbersChangedEvent OnNumbersChanged', e);
            }
        }
    },
    
    _fireBetsChangedEvent$1: function NumbersService_NumbersService$_fireBetsChangedEvent$1(betTotals) {
        NumbersService.NumbersService._log$1.debug('FireBetsChangedEvent');
        var $enum1 = this._betsChangedListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onBetTotalsChanged(this, betTotals);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireBetsChangedEvent OnBetTotalsChanged', e);
            }
        }
    },
    
    _fireDrawsChangedEvent$1: function NumbersService_NumbersService$_fireDrawsChangedEvent$1(idfolotterydrawpatterns, includeBonusBall) {
        NumbersService.NumbersService._log$1.debug('FireDrawsChangedEvent');
        var $enum1 = this._drawsChangedListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onDrawsChanged(this, idfolotterydrawpatterns, includeBonusBall, this.getPriceType(includeBonusBall));
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireDrawsChangedEvent OnDrawsChanged', e);
            }
        }
    },
    
    _fireMarketsChangedEvent$1: function NumbersService_NumbersService$_fireMarketsChangedEvent$1(idfomarkets) {
        NumbersService.NumbersService._log$1.debug('FireMarketsChangedEvent');
        var $enum1 = this._drawsChangedListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onMarketsChanged(this, idfomarkets);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireMarketsChangedEvent OnMarketsChanged', e);
            }
        }
    },
    
    _fireBetPreviewReadyEvent$1: function NumbersService_NumbersService$_fireBetPreviewReadyEvent$1(preview) {
        NumbersService.NumbersService._log$1.debug('FireBetPreviewReadyEvent');
        var $enum1 = this._betPlacementListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onBetPreviewReady(this, preview);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireBetPreviewReadyEvent OnBetPreviewReady', e);
            }
        }
    },
    
    _fireWeeksSubscribedEvent$1: function NumbersService_NumbersService$_fireWeeksSubscribedEvent$1(weeksAhead) {
        NumbersService.NumbersService._log$1.debug('FireWeeksSubscribedEvent');
        var $enum1 = this._drawsChangedListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onWeeksSubscribedChanged(this, weeksAhead);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireWeeksSubscribedEvent', e);
            }
        }
    },
    
    _fireBetPlacementFailureEvent$1: function NumbersService_NumbersService$_fireBetPlacementFailureEvent$1(ticketInbound, ticketOutbound) {
        NumbersService.NumbersService._log$1.debug('FireBetPlacementFailureEvent');
        var $enum1 = this._betPlacementListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onBetPlacementFailure(this, ticketInbound, ticketOutbound);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireBetPlacementFailureEvent OnBetPlacementFailure', e);
            }
        }
    },
    
    _fireBetPlacementSuccessEvent$1: function NumbersService_NumbersService$_fireBetPlacementSuccessEvent$1(ticketOutbound) {
        NumbersService.NumbersService._log$1.debug('FireBetPlacementSuccessEvent');
        var $enum1 = this._betPlacementListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onBetPlacementSuccess(this, ticketOutbound);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireBetPlacementSuccessEvent OnBetPlacementSuccess', e);
            }
        }
    },
    
    _fireConfirmationRequiredEvent$1: function NumbersService_NumbersService$_fireConfirmationRequiredEvent$1(ticketOutbound) {
        NumbersService.NumbersService._log$1.debug('FireConfirmationRequiredEvent');
        var $enum1 = this._betPlacementListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onConfirmationRequired(this, ticketOutbound);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireConfirmationRequiredEvent OnConfirmationRequired', e);
            }
        }
    },
    
    _fireTicketRejectedEvent$1: function NumbersService_NumbersService$_fireTicketRejectedEvent$1(ticketOutbound) {
        NumbersService.NumbersService._log$1.debug('FireTicketRejectedEvent');
        var $enum1 = this._betPlacementListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onRejected(this, ticketOutbound);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireTicketRejectedEvent OnRejected', e);
            }
        }
    },
    
    _fireWaitingForResponseEvent$1: function NumbersService_NumbersService$_fireWaitingForResponseEvent$1() {
        NumbersService.NumbersService._log$1.debug('FireWaitingForResponseEvent');
        var $enum1 = this._betPlacementListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onWaitingForResponse(this);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireWaitingForResponseEvent OnWaitingForResponse', e);
            }
        }
    },
    
    _fireNotWaitingForResponseEvent$1: function NumbersService_NumbersService$_fireNotWaitingForResponseEvent$1() {
        NumbersService.NumbersService._log$1.debug('FireNotWaitingForResponseEvent');
        var $enum1 = this._betPlacementListeners$1.getEnumerator();
        while ($enum1.moveNext()) {
            var listener = $enum1.get_current();
            try {
                listener.onNotWaitingForResponse(this);
            }
            catch (e) {
                NumbersService.NumbersService._log$1.error('FireWaitingForResponseEvent OnNotWaitingForResponse', e);
            }
        }
    },
    
    onPageWillChange: function NumbersService_NumbersService$onPageWillChange() {
        this._environment.storeState(NumbersService.NumbersService._serviceName$1, this._getServiceState$1());
    },
    
    _placeTicket$1: function NumbersService_NumbersService$_placeTicket$1(successCallback, failureCallback, ticket, useAutoAcceptance) {
        NumbersService.NumbersService._log$1.debug(String.format('PlaceTicket ticket=[{0}] ', ticket));
        this._fireWaitingForResponseEvent$1();
        this._environment.invokeAsync(NumbersService.NumbersService._serviceName$1, 'PlaceTicket', { ticketInbound: ticket, useAutoAcceptance: useAutoAcceptance, iddcLanguage: this._environment.getLanguage() }, Delegate.create(this, function(result) {
            this._fireNotWaitingForResponseEvent$1();
            if (successCallback) {
                successCallback.invoke(result);
            }
            this._accountService$1.fetchAccountsDetails();
        }), Delegate.create(this, function(exception) {
            NumbersService.NumbersService._log$1.debug('PlaceTicket exception' + exception.message);
            this._fireNotWaitingForResponseEvent$1();
            if (failureCallback) {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    _confirmTicket$1: function NumbersService_NumbersService$_confirmTicket$1(successCallback, failureCallback, IDFOBetSlip, ticketStatus) {
        NumbersService.NumbersService._log$1.debug(String.format('ConfirmTicket ticketStatus=[{0}] IDFOBetSlip=[{1}]', ticketStatus, IDFOBetSlip));
        this._fireWaitingForResponseEvent$1();
        this._environment.invokeAsync(NumbersService.NumbersService._serviceName$1, 'ConfirmTicket', { IDFOBetSlip: IDFOBetSlip, ticketStatus: ticketStatus, iddcLanguage: this._environment.getLanguage() }, Delegate.create(this, function(result) {
            this._fireNotWaitingForResponseEvent$1();
            if (successCallback) {
                successCallback.invoke(result);
            }
        }), Delegate.create(this, function(exception) {
            NumbersService.NumbersService._log$1.debug('ConfirmTicket exception' + exception.message);
            this._fireNotWaitingForResponseEvent$1();
            if (failureCallback) {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    _rejectTicket$1: function NumbersService_NumbersService$_rejectTicket$1(successCallback, failureCallback, IDFOBetSlip, ticketStatus) {
        NumbersService.NumbersService._log$1.debug(String.format('RejectTicket ticketStatus=[{0}] IDFOBetSlip=[{1}]', ticketStatus, IDFOBetSlip));
        this._fireWaitingForResponseEvent$1();
        this._environment.invokeAsync(NumbersService.NumbersService._serviceName$1, 'RejectTicket', { IDFOBetSlip: IDFOBetSlip, ticketStatus: ticketStatus, iddcLanguage: this._environment.getLanguage() }, Delegate.create(this, function(result) {
            this._fireNotWaitingForResponseEvent$1();
            if (successCallback) {
                successCallback.invoke(result);
            }
        }), Delegate.create(this, function(exception) {
            NumbersService.NumbersService._log$1.debug('RejectTicket exception' + exception.message);
            this._fireNotWaitingForResponseEvent$1();
            if (failureCallback) {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    _getTicketStatus$1: function NumbersService_NumbersService$_getTicketStatus$1(successCallback, failureCallback, IDFOBetSlip) {
        NumbersService.NumbersService._log$1.debug(String.format('GetTicketStatus IDFOBetSlip=[{0}]', IDFOBetSlip));
        this._fireWaitingForResponseEvent$1();
        this._environment.invokeAsync(NumbersService.NumbersService._serviceName$1, 'GetTicketStatus', { IDFOBetSlip: IDFOBetSlip, iddcLanguage: this._environment.getLanguage() }, Delegate.create(this, function(result) {
            this._fireNotWaitingForResponseEvent$1();
            if (successCallback) {
                successCallback.invoke(result);
            }
        }), Delegate.create(this, function(exception) {
            NumbersService.NumbersService._log$1.debug('GetTicketStatus exception' + exception.message);
            this._fireNotWaitingForResponseEvent$1();
            if (failureCallback) {
                failureCallback.invoke(exception);
            }
        }));
    },
    
    _getSeedValues$1: function NumbersService_NumbersService$_getSeedValues$1(successCallback, failureCallback) {
        NumbersService.NumbersService._log$1.debug('GetSeedValues');
        var state = this._getCurrentLotteryState$1();
        if (!state.dummyIDFOMarket || !state.dummyIDFOMarket.trim().length) {
            if (successCallback) {
                successCallback.invoke({});
            }
        }
        else {
            this._environment.invokeAsync(NumbersService.NumbersService._serviceName$1, 'GetSeedValues', { idfoMarket: state.dummyIDFOMarket, priceTypes: state.dummyPriceTypes, availableBetTypes: state.dummyBetTypes, maxBallsCount: this._maxMultipleBalls$1, iddcLanguage: this._environment.getLanguage() }, Delegate.create(this, function(result) {
                if (successCallback) {
                    successCallback.invoke(result);
                }
            }), Delegate.create(this, function(exception) {
                NumbersService.NumbersService._log$1.debug('GetSeedValues exception' + exception.message);
                if (failureCallback) {
                    failureCallback.invoke(exception);
                }
            }));
        }
    },
    
    isBetConfirmationScreenShownBeforePlacement: function NumbersService_NumbersService$isBetConfirmationScreenShownBeforePlacement() {
        try {
            return this._fixedOddsBettingService.getPreferences().IsBetConfirmationScreenShownBeforePlacement;
        }
        catch (e) {
            NumbersService.NumbersService._log$1.error('IsBetConfirmationScreenShownBeforePlacement', e);
            return true;
        }
    },
    
    isBetConfirmationScreenShownAfterPlacement: function NumbersService_NumbersService$isBetConfirmationScreenShownAfterPlacement() {
        try {
            return this._fixedOddsBettingService.getPreferences().IsBetConfirmationScreenShownAfterPlacement;
        }
        catch (e) {
            NumbersService.NumbersService._log$1.error('IsBetConfirmationScreenShownAfterPlacement', e);
            return true;
        }
    },
    
    getMaxMultipleBalls: function NumbersService_NumbersService$getMaxMultipleBalls() {
        return this._maxMultipleBalls$1;
    },
    
    getMaxStraightLines: function NumbersService_NumbersService$getMaxStraightLines() {
        return this._maxStraightLines$1;
    },
    
    setLottery: function NumbersService_NumbersService$setLottery(idfosport) {
        NumbersService.NumbersService._log$1.debug('SetLottery');
        if (this._idfoSport$1 === idfosport) {
            return;
        }
        this._fireLotteryChangedEvent$1(idfosport);
        this._idfoSport$1 = idfosport;
    },
    
    getLottery: function NumbersService_NumbersService$getLottery() {
        NumbersService.NumbersService._log$1.debug('GetLottery');
        return this._idfoSport$1;
    },
    
    _addCsvAvailableBetTypes$1: function NumbersService_NumbersService$_addCsvAvailableBetTypes$1(idfolotterydrawpattern, csvavailablebettypes) {
        this._getCurrentLotteryState$1().csvAvailableBetTypes[idfolotterydrawpattern] = csvavailablebettypes;
    },
    
    _removeCsvAvailableBetTypes$1: function NumbersService_NumbersService$_removeCsvAvailableBetTypes$1(idfolotterydrawpattern) {
        if (Object.keyExists(this._getCurrentLotteryState$1().csvAvailableBetTypes, idfolotterydrawpattern)) {
            delete this._getCurrentLotteryState$1().csvAvailableBetTypes[idfolotterydrawpattern];
        }
    },
    
    getAvailableBetTypes: function NumbersService_NumbersService$getAvailableBetTypes() {
        var availableBetTypes = [];
        var $dict1 = this._getCurrentLotteryState$1().csvAvailableBetTypes;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var betTypes = (entry.value).split(',');
            var $enum3 = betTypes.getEnumerator();
            while ($enum3.moveNext()) {
                var bettype = $enum3.get_current();
                if (bettype && bettype.trim().length > 0) {
                    var val = bettype.trim();
                    if (!availableBetTypes.contains(val)) {
                        availableBetTypes.add(val);
                    }
                }
            }
        }
        return availableBetTypes;
    },
    
    addMarket: function NumbersService_NumbersService$addMarket(idfoMarket, idfoDrawPattern) {
        this._addMarketInt$1(idfoMarket, idfoDrawPattern, true);
    },
    
    addMarkets: function NumbersService_NumbersService$addMarkets(idfoDrawPatternsToMarkets) {
        if (!idfoDrawPatternsToMarkets) {
            return;
        }
        var $dict1 = idfoDrawPatternsToMarkets;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (entry.value && entry.key) {
                var idfoMarkets = entry.value;
                if (idfoMarkets) {
                    var $enum3 = idfoMarkets.getEnumerator();
                    while ($enum3.moveNext()) {
                        var idfoMarket = $enum3.get_current();
                        this._addMarketInt$1(idfoMarket, entry.key, false);
                    }
                }
            }
        }
        this._recalculateBetTotals$1();
        this._fireMarketsChangedEvent$1(this.getMarkets());
    },
    
    removeMarket: function NumbersService_NumbersService$removeMarket(idfoMarket, idfoDrawPattern) {
        this._removeMarketInt$1(idfoMarket, idfoDrawPattern, true);
    },
    
    removeMarkets: function NumbersService_NumbersService$removeMarkets(idfoDrawPatternsToMarkets) {
        if (!idfoDrawPatternsToMarkets) {
            return;
        }
        var $dict1 = idfoDrawPatternsToMarkets;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (entry.value && entry.key) {
                var idfoMarkets = entry.value;
                if (idfoMarkets) {
                    var $enum3 = idfoMarkets.getEnumerator();
                    while ($enum3.moveNext()) {
                        var idfoMarket = $enum3.get_current();
                        this._removeMarketInt$1(idfoMarket, entry.key, false);
                    }
                }
            }
        }
        this._recalculateBetTotals$1();
        this._fireMarketsChangedEvent$1(this.getMarkets());
    },
    
    getMarketsForDrawPattern: function NumbersService_NumbersService$getMarketsForDrawPattern(idfoDrawPattern) {
        return (this._getCurrentLotteryState$1().idfOlotterydrawpatternToMarket[idfoDrawPattern]) || new Array(0);
    },
    
    getMarkets: function NumbersService_NumbersService$getMarkets() {
        var markets = [];
        var $dict1 = this._getCurrentLotteryState$1().idfOlotterydrawpatternToMarket;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            markets.addRange(entry.value);
        }
        return markets;
    },
    
    addDraw: function NumbersService_NumbersService$addDraw(idfolotterydrawpattern, csvavailablebettypes) {
        var drawPatterns = this.getDrawPatterns();
        if (!drawPatterns.contains(idfolotterydrawpattern)) {
            var idfolotterydrawpatterns = new Array(drawPatterns.length + 1);
            for (var i = 0; i < drawPatterns.length; i++) {
                idfolotterydrawpatterns[i] = drawPatterns[i];
            }
            idfolotterydrawpatterns[idfolotterydrawpatterns.length - 1] = idfolotterydrawpattern;
            this._setDrawPatterns$1(idfolotterydrawpatterns);
            this._addCsvAvailableBetTypes$1(idfolotterydrawpattern, csvavailablebettypes);
            this._recalculateBetTotals$1();
            this._fireDrawsChangedEvent$1(this.getDrawPatterns(), this.getIncludeBonusBall());
            this._fireMarketsChangedEvent$1(this.getMarkets());
        }
    },
    
    removeDraw: function NumbersService_NumbersService$removeDraw(idfolotterydrawpattern) {
        var drawPatterns = this.getDrawPatterns();
        if (drawPatterns.contains(idfolotterydrawpattern)) {
            var idfolotterydrawpatterns = new Array(drawPatterns.length - 1);
            var index = 0;
            for (var i = 0; i < drawPatterns.length; i++) {
                if (drawPatterns[i] !== idfolotterydrawpattern) {
                    idfolotterydrawpatterns[index] = drawPatterns[i];
                    index++;
                }
            }
            this._setDrawPatterns$1(idfolotterydrawpatterns);
            this._removeCsvAvailableBetTypes$1(idfolotterydrawpattern);
            this._recalculateBetTotals$1();
            this._setMarketsForDrawPattern$1(idfolotterydrawpattern, new Array(0));
            this._fireDrawsChangedEvent$1(this.getDrawPatterns(), this.getIncludeBonusBall());
            this._fireMarketsChangedEvent$1(this.getMarkets());
        }
    },
    
    getDrawPatterns: function NumbersService_NumbersService$getDrawPatterns() {
        return this._getCurrentLotteryState$1().idfOlotterydrawpatterns || new Array(0);
    },
    
    getErrorMessage: function NumbersService_NumbersService$getErrorMessage(componentDomElementId, ex) {
        var ele = this._environment.getDomElement(String.format('{0}-error-{1}', componentDomElementId, ex.message));
        var parts = ex.message.split('|');
        if (ele) {
            var eleparts = ele.value.split('|');
            if (parts.length === 2 && eleparts.length === 2) {
                return parts[1].replace(eleparts[0], eleparts[1]);
            }
            else {
                return ex.message;
            }
        }
        else {
            if (parts.length > 1) {
                return parts[1];
            }
            else {
                return ex.message;
            }
        }
    },
    
    setIncludeBonusBall: function NumbersService_NumbersService$setIncludeBonusBall(includeBonusBall) {
        var state = this._getCurrentLotteryState$1();
        state.includeBonusBall = includeBonusBall;
        if (state.ballSets) {
            var $dict1 = state.ballSets;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                this._recalculateBets$1(entry.value, false);
            }
            this._recalculateBetTotals$1();
        }
        this._fireDrawsChangedEvent$1(this.getDrawPatterns(), includeBonusBall);
    },
    
    getIncludeBonusBall: function NumbersService_NumbersService$getIncludeBonusBall() {
        return this._getCurrentLotteryState$1().includeBonusBall;
    },
    
    getPriceType: function NumbersService_NumbersService$getPriceType(includeBonusBall) {
        if (includeBonusBall) {
            return 'BST';
        }
        else {
            return 'REG';
        }
    },
    
    getCurrentBallSet: function NumbersService_NumbersService$getCurrentBallSet() {
        var state = this._getCurrentLotteryState$1();
        if (!state.currentBallSet) {
            this._setCurrentBallSetInner$1(state, NumbersService.NumbersService.linE_TYPE_STRAIGHTS, 1, this._maxMultipleBalls$1);
        }
        return state.currentBallSet;
    },
    
    setCurrentBallSet: function NumbersService_NumbersService$setCurrentBallSet(type, lineNumber, maxNumberOfBalls) {
        var state = this._getCurrentLotteryState$1();
        this._setCurrentBallSetInner$1(state, type, lineNumber, maxNumberOfBalls);
        this._fireCurrentBallSetChangedEvent$1(state.currentBallSet);
    },
    
    setStake: function NumbersService_NumbersService$setStake(lineType, linenumber, stake, index) {
        var ballset = this._getBallSet$1(this._getCurrentLotteryState$1(), lineType, linenumber);
        var betIndex = index - 1;
        if (!ballset.bets[betIndex]) {
            var bet = new NumbersService.Bet();
            ballset.bets[betIndex] = bet;
        }
        ballset.bets[betIndex].stake = stake;
        this._recalculateBets$1(ballset, true);
        this._fireCurrentBallSetBetsChangedEvent$1(ballset);
    },
    
    setBetType: function NumbersService_NumbersService$setBetType(index, betType) {
        var currentBallset = this.getCurrentBallSet();
        var betIndex = index - 1;
        if (!currentBallset.bets[betIndex]) {
            var bet = new NumbersService.Bet();
            currentBallset.bets[betIndex] = bet;
        }
        currentBallset.bets[betIndex].betTypeCode = betType;
        this._recalculateBets$1(currentBallset, true);
        this._fireCurrentBallSetBetsChangedEvent$1(currentBallset);
    },
    
    addBall: function NumbersService_NumbersService$addBall(number) {
        var currentBallset = this.getCurrentBallSet();
        currentBallset.addBall(number);
        this._recalculateBets$1(currentBallset, true);
        this._fireNumbersChangedEvent$1(currentBallset);
    },
    
    removeBall: function NumbersService_NumbersService$removeBall(number) {
        var currentBallset = this.getCurrentBallSet();
        currentBallset.removeBall(number);
        this._recalculateBets$1(currentBallset, true);
        this._fireNumbersChangedEvent$1(currentBallset);
    },
    
    removeBallForLineColumn: function NumbersService_NumbersService$removeBallForLineColumn(lineType, lineNumber, colNumber) {
        var ballSet = this._getBallSet$1(this._getCurrentLotteryState$1(), lineType, lineNumber);
        if (ballSet) {
            var balls = ballSet.getBalls();
            if (balls && balls.length >= colNumber) {
                var number = balls[colNumber - 1].Number;
                ballSet.removeBall(number);
                this._recalculateBets$1(ballSet, true);
                this._fireNumbersChangedEvent$1(ballSet);
            }
        }
    },
    
    pickRandomBalls: function NumbersService_NumbersService$pickRandomBalls(numberToPick, numberToPickFrom) {
        var ballSet = this.getCurrentBallSet();
        var clonedBets = new Array(ballSet.bets.length);
        for (var index = 0; index < ballSet.bets.length; index++) {
            clonedBets[index] = new NumbersService.Bet();
            clonedBets[index].betTypeCode = ballSet.bets[index].betTypeCode;
            clonedBets[index].potentialReturn = ballSet.bets[index].potentialReturn;
            clonedBets[index].stake = ballSet.bets[index].stake;
            clonedBets[index].totalStake = ballSet.bets[index].totalStake;
            clonedBets[index].unitCount = ballSet.bets[index].unitCount;
        }
        ballSet.clear();
        while (ballSet.getNumberOfBalls() < numberToPick) {
            var random = Math.random() * numberToPickFrom;
            var ballToAdd = Math.ceil(random);
            ballSet.addBall(ballToAdd);
        }
        for (var i = 0; i < clonedBets.length; i++) {
            var clonedBet = clonedBets[i];
            var betTypes;
            if (ballSet.type === 'multiples') {
                betTypes = this.getMultilineBetTypes(i + 1);
            }
            else {
                betTypes = new Array(1);
                betTypes[0] = new NumbersService.BetType();
                betTypes[0].IDFOBetType = 'A';
                betTypes[0].Name = 'Straight';
                betTypes[0].IsEachWayAllowed = false;
            }
            if (this.isBetTypeCodeIn(clonedBet.betTypeCode, betTypes)) {
                var newBet = new NumbersService.Bet();
                newBet.betTypeCode = clonedBet.betTypeCode;
                newBet.potentialReturn = clonedBet.potentialReturn;
                newBet.stake = clonedBet.stake;
                newBet.totalStake = clonedBet.totalStake;
                newBet.unitCount = clonedBet.unitCount;
                ballSet.bets[i] = newBet;
            }
        }
        this._recalculateBets$1(ballSet, true);
        this._fireNumbersChangedEvent$1(ballSet);
    },
    
    isBetTypeCodeIn: function NumbersService_NumbersService$isBetTypeCodeIn(betTypeCode, betTypes) {
        for (var x = 0; x < betTypes.length; x++) {
            if (betTypes[x].IDFOBetType === betTypeCode) {
                return true;
            }
        }
        return false;
    },
    
    clearBalls: function NumbersService_NumbersService$clearBalls() {
        var ballSet = this.getCurrentBallSet();
        ballSet.clear();
        this._recalculateBets$1(ballSet, true);
        this._fireNumbersChangedEvent$1(this.getCurrentBallSet());
    },
    
    getNumbers: function NumbersService_NumbersService$getNumbers(balls) {
        var numbers = new Array(balls.length);
        for (var i = 0; i < balls.length; i++) {
            numbers[i] = balls[i].Number;
        }
        return numbers;
    },
    
    getAllBallSets: function NumbersService_NumbersService$getAllBallSets() {
        var ballSets = [];
        var state = this._getCurrentLotteryState$1();
        var ballSetsD = state.ballSets;
        var $dict1 = ballSetsD;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            ballSets.add(entry.value);
        }
        return ballSets;
    },
    
    setDummyTicketValues: function NumbersService_NumbersService$setDummyTicketValues(idfoMarket, csvPriceTypes, csvBetTypes) {
        var state = this._getCurrentLotteryState$1();
        state.dummyIDFOMarket = idfoMarket;
        if (csvPriceTypes && csvPriceTypes.trim().length > 0) {
            state.dummyPriceTypes = csvPriceTypes.split(',');
        }
        else {
            state.dummyPriceTypes = new Array(0);
        }
        if (csvBetTypes && csvBetTypes.trim().length > 0) {
            state.dummyBetTypes = csvBetTypes.split(',');
        }
        else {
            state.dummyBetTypes = new Array(0);
        }
        this._getSeedValues$1(Delegate.create(this, this._onGetSeedValuesComplete$1), null);
    },
    
    getMultilineBetTypes: function NumbersService_NumbersService$getMultilineBetTypes(rowIndex) {
        var state = this._getCurrentLotteryState$1();
        var ballset = this.getCurrentBallSet();
        if (!ballset) {
            return new Array(0);
        }
        var ccValue = this._getColumnCountSeedValue$1(ballset, Math.min(rowIndex, ballset.getNumberOfBalls()));
        if (!ccValue) {
            return new Array(0);
        }
        var betTypes = [];
        var $dict1 = ccValue.BettypeSeedValues;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var bettype = state.seedValues.BetTypes[entry.key];
            betTypes.add(bettype);
        }
        return betTypes;
    },
    
    getBetTypeDescription: function NumbersService_NumbersService$getBetTypeDescription(betTypeCode) {
        var state = this._getCurrentLotteryState$1();
        if (!state.seedValues || !Object.keyExists(state.seedValues.BetTypes, betTypeCode)) {
            return betTypeCode;
        }
        else {
            return (state.seedValues.BetTypes[betTypeCode]).Name;
        }
    },
    
    getBetTotals: function NumbersService_NumbersService$getBetTotals() {
        return this._getCurrentLotteryState$1().betTotals;
    },
    
    placeBets: function NumbersService_NumbersService$placeBets() {
        if (this._userService$1.isLoggedIn()) {
            this._fireBetPreviewReadyEvent$1(this.getBetSlipPreview());
            this._navigationService$1.goTo(this._navigationService$1.getPageArea(), { action: this.get_lottoBetPlacementPageAction() });
            if (!this._fixedOddsBettingService.getPreferences().IsBetConfirmationScreenShownBeforePlacement) {
                this.placeBetsConfirmed(null);
            }
        }
        else {
            throw new Error('notloggedin|Please log in before placing your bet');
        }
    },
    
    getBetSlipPreview: function NumbersService_NumbersService$getBetSlipPreview() {
        var state = this._getCurrentLotteryState$1();
        var ticket = [];
        var idfoMarkets = this.getMarkets();
        var idfoPriceType = this.getPriceType(state.includeBonusBall);
        if (!idfoMarkets || !idfoMarkets.length) {
            return new Array(0);
        }
        var $dict1 = state.ballSets;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var ballset = entry.value;
            var balls = ballset.getBalls();
            if (!ballset.bets || !ballset.bets.length || !balls || !balls.length) {
                continue;
            }
            var $enum3 = idfoMarkets.getEnumerator();
            while ($enum3.moveNext()) {
                var idfoMarket = $enum3.get_current();
                for (var betIndex = 0; betIndex < ballset.bets.length; betIndex++) {
                    var bet = ballset.bets[betIndex];
                    if (bet.stake > 0) {
                        var line = new NumbersService.LineOutbound();
                        line.IDFOBetType = bet.betTypeCode;
                        line.IDFOMarket = Number.parse(idfoMarket);
                        line.IDFOPriceType = idfoPriceType;
                        line.PotentialReturn = bet.potentialReturn;
                        line.TotalStake = bet.totalStake;
                        line.UnitCount = bet.unitCount;
                        line.Stake = bet.stake;
                        if (ballset.type === NumbersService.NumbersService.linE_TYPE_MULTIPLES) {
                            line.Balls = new Array(betIndex + 1);
                            for (var ballIndex = 0; ballIndex <= betIndex; ballIndex++) {
                                line.Balls[ballIndex] = balls[ballIndex];
                            }
                        }
                        else {
                            line.Balls = balls;
                        }
                        ticket.add(line);
                    }
                }
            }
        }
        return ticket;
    },
    
    showLotto: function NumbersService_NumbersService$showLotto() {
        this._navigationService$1.goTo(this._navigationService$1.getPageArea(), { action: this._lottoHomePageAction$1 });
    },
    
    placeBetsConfirmed: function NumbersService_NumbersService$placeBetsConfirmed(securityCode) {
        var state = this._getCurrentLotteryState$1();
        var idfoMarkets = this.getMarkets();
        var idfoPriceType = this.getPriceType(state.includeBonusBall);
        if (!idfoMarkets || !idfoMarkets.length) {
            return;
        }
        var $dict1 = state.ballSets;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var ballset = entry.value;
            var balls = ballset.getBalls();
            if (!ballset.bets || !ballset.bets.length || !balls || !balls.length) {
                continue;
            }
            var ticket = new NumbersService.TicketInbound();
            ticket.IsFree = state.placeUsingFree;
            var lines = [];
            var $enum3 = idfoMarkets.getEnumerator();
            while ($enum3.moveNext()) {
                var idfoMarket = $enum3.get_current();
                for (var betIndex = 0; betIndex < ballset.bets.length; betIndex++) {
                    var bet = ballset.bets[betIndex];
                    if (bet.stake > 0) {
                        var line = new NumbersService.LineInbound();
                        line.IDFOBetType = bet.betTypeCode;
                        line.IDFOMarket = Number.parse(idfoMarket);
                        line.IDFOPriceType = idfoPriceType;
                        line.Stake = bet.stake;
                        if (ballset.type === NumbersService.NumbersService.linE_TYPE_MULTIPLES) {
                            line.Balls = new Array(betIndex + 1);
                            for (var ballIndex = 0; ballIndex <= betIndex; ballIndex++) {
                                line.Balls[ballIndex] = balls[ballIndex];
                            }
                        }
                        else {
                            line.Balls = balls;
                        }
                        lines.add(line);
                    }
                }
            }
            ticket.Lines = lines;
            this._placeTicket$1(Delegate.create(this, this._onPlaceTicketComplete$1), Delegate.create(this, this._onRPCFailed$1), ticket, true);
        }
    },
    
    setPlaceUsingFree: function NumbersService_NumbersService$setPlaceUsingFree(placeUsingFree) {
        this._getCurrentLotteryState$1().placeUsingFree = placeUsingFree;
        this._fireBetsChangedEvent$1(this.getBetTotals());
    },
    
    getPlaceUsingFree: function NumbersService_NumbersService$getPlaceUsingFree() {
        return this._getCurrentLotteryState$1().placeUsingFree;
    },
    
    confirmTicket: function NumbersService_NumbersService$confirmTicket(securityCode) {
        var state = this._getCurrentLotteryState$1();
        this._confirmTicket$1(Delegate.create(this, this._onConfirmTicketComplete$1), Delegate.create(this, this._onRPCFailed$1), state.placedTicket.IDFOBetSlip, state.placedTicket.Status);
    },
    
    rejectTicket: function NumbersService_NumbersService$rejectTicket() {
        var state = this._getCurrentLotteryState$1();
        this._rejectTicket$1(Delegate.create(this, this._onRejectTicketComplete$1), Delegate.create(this, this._onRPCFailed$1), state.placedTicket.IDFOBetSlip, state.placedTicket.Status);
    },
    
    getRealPotentialProfit: function NumbersService_NumbersService$getRealPotentialProfit(potentialProfit, stake) {
        var result = potentialProfit;
        if (this.getPlaceUsingFree()) {
            result -= stake;
        }
        return result;
    },
    
    _onRejectTicketComplete$1: function NumbersService_NumbersService$_onRejectTicketComplete$1(result) {
        this._fireTicketRejectedEvent$1(this._getCurrentLotteryState$1().placedTicket);
    },
    
    _parseOutboundTicket$1: function NumbersService_NumbersService$_parseOutboundTicket$1(ticket) {
        switch (ticket.Status.State) {
            case NumbersService.TicketStates.waiting:
                this._getTicketStatus$1(Delegate.create(this, this._onGetTicketStatusComplete$1), Delegate.create(this, this._onRPCFailed$1), ticket.IDFOBetSlip);
                break;
            case NumbersService.TicketStates.acceptable:
                this._confirmTicket$1(Delegate.create(this, this._onConfirmTicketComplete$1), Delegate.create(this, this._onRPCFailed$1), ticket.IDFOBetSlip, ticket.Status);
                break;
            case NumbersService.TicketStates.accepted:
                this._clearCurrentLotteryState$1();
                this._fireBetPlacementSuccessEvent$1(ticket);
                break;
            case NumbersService.TicketStates.confirmationRequired:
                this._fireConfirmationRequiredEvent$1(ticket);
                break;
            case NumbersService.TicketStates.preProcess:
                break;
            case NumbersService.TicketStates.rejected:
                this._getCurrentLotteryState$1().placedTicket = null;
                this._fireTicketRejectedEvent$1(ticket);
                break;
        }
    },
    
    _onPlaceTicketComplete$1: function NumbersService_NumbersService$_onPlaceTicketComplete$1(result) {
        this._getCurrentLotteryState$1().placedTicket = result;
        this._parseOutboundTicket$1(this._getCurrentLotteryState$1().placedTicket);
    },
    
    _onGetTicketStatusComplete$1: function NumbersService_NumbersService$_onGetTicketStatusComplete$1(result) {
        this._getCurrentLotteryState$1().placedTicket.Status = result;
        this._parseOutboundTicket$1(this._getCurrentLotteryState$1().placedTicket);
    },
    
    _onConfirmTicketComplete$1: function NumbersService_NumbersService$_onConfirmTicketComplete$1(result) {
        this._getCurrentLotteryState$1().placedTicket.Status = result;
        this._parseOutboundTicket$1(this._getCurrentLotteryState$1().placedTicket);
    },
    
    _onRPCFailed$1: function NumbersService_NumbersService$_onRPCFailed$1(exception) {
        alert(Framework.ExceptionUtil.getExceptionDetails(exception).get_message());
    },
    
    onUserChanged: function NumbersService_NumbersService$onUserChanged(eventSource) {
    }
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.NumbersServiceState

NumbersService.NumbersServiceState = function NumbersService_NumbersServiceState() {
    this.ballSets = {};
    this.idfOlotterydrawpatterns = new Array(0);
    this.idfOlotterydrawpatternToMarket = {};
    this.csvAvailableBetTypes = {};
    this.betTotals = new NumbersService.Bet();
}
NumbersService.NumbersServiceState.prototype = {
    currentBallSet: null,
    idfOsport: null,
    includeBonusBall: false,
    dummyIDFOMarket: null,
    dummyPriceTypes: null,
    dummyBetTypes: null,
    seedValues: null,
    placeUsingFree: false,
    placedTicket: null
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.PriceTypeSeedValue

NumbersService.PriceTypeSeedValue = function NumbersService_PriceTypeSeedValue() {
}
NumbersService.PriceTypeSeedValue.prototype = {
    PriceType: null,
    ColumnCountSeedValues: null
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.SeedValues

NumbersService.SeedValues = function NumbersService_SeedValues() {
}
NumbersService.SeedValues.prototype = {
    IDFOMarket: null,
    PriceTypeSeedValues: null,
    BetTypes: null
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.TicketInbound

NumbersService.TicketInbound = function NumbersService_TicketInbound() {
}
NumbersService.TicketInbound.prototype = {
    Lines: null,
    IsFree: false
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.TicketOutbound

NumbersService.TicketOutbound = function NumbersService_TicketOutbound() {
}
NumbersService.TicketOutbound.prototype = {
    ExternalReference: null,
    IDFOBetSlip: null,
    Lines: null,
    PotentialReturn: 0,
    Status: null,
    TopupAmount: null,
    TotalStake: null
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.TicketStates

NumbersService.TicketStates = function NumbersService_TicketStates() {
}


////////////////////////////////////////////////////////////////////////////////
// NumbersService.TicketStatus

NumbersService.TicketStatus = function NumbersService_TicketStatus() {
}
NumbersService.TicketStatus.prototype = {
    DetailedState: 0,
    State: 0,
    StatusCode: null,
    StatusText: null
}


NumbersService.Ball.createClass('NumbersService.Ball');
NumbersService.BallSet.createClass('NumbersService.BallSet');
NumbersService._ballSetState.createClass('NumbersService._ballSetState');
NumbersService.Bet.createClass('NumbersService.Bet');
NumbersService.BetType.createClass('NumbersService.BetType');
NumbersService.BettypeSeedValue.createClass('NumbersService.BettypeSeedValue');
NumbersService.CalculatedLine.createClass('NumbersService.CalculatedLine');
NumbersService.ColumnCountSeedValue.createClass('NumbersService.ColumnCountSeedValue');
NumbersService.DetailedTicketStates.createClass('NumbersService.DetailedTicketStates');
NumbersService.LineInbound.createClass('NumbersService.LineInbound');
NumbersService.LineOutbound.createClass('NumbersService.LineOutbound');
NumbersService.NumbersService.createClass('NumbersService.NumbersService', Framework.AbstractService, Framework.IPageWillChangeListener, UserService.IUserChangedListener);
NumbersService.NumbersServiceState.createClass('NumbersService.NumbersServiceState');
NumbersService.PriceTypeSeedValue.createClass('NumbersService.PriceTypeSeedValue');
NumbersService.SeedValues.createClass('NumbersService.SeedValues');
NumbersService.TicketInbound.createClass('NumbersService.TicketInbound');
NumbersService.TicketOutbound.createClass('NumbersService.TicketOutbound');
NumbersService.TicketStates.createClass('NumbersService.TicketStates');
NumbersService.TicketStatus.createClass('NumbersService.TicketStatus');
NumbersService.DetailedTicketStates.preProcess = 0;
NumbersService.DetailedTicketStates.accepted = 1;
NumbersService.DetailedTicketStates.acceptable = 2;
NumbersService.DetailedTicketStates.rejected = 4;
NumbersService.DetailedTicketStates.reoffered = 64;
NumbersService.DetailedTicketStates.reofferTimeout = 128;
NumbersService.DetailedTicketStates.topupRequired = 256;
NumbersService.DetailedTicketStates.maxTakeoutViolation = 512;
NumbersService.DetailedTicketStates.waiting = 1024;
NumbersService.DetailedTicketStates.abortProcessing = 4096;
NumbersService.DetailedTicketStates.securityCodeRequiredForTopup = 16384;
NumbersService.NumbersService.linE_TYPE_MULTIPLES = 'multiples';
NumbersService.NumbersService.linE_TYPE_STRAIGHTS = 'straights';
NumbersService.NumbersService._serviceName$1 = 'NumbersService';
NumbersService.NumbersService._log$1 = Framework.Logger.getLog(NumbersService.NumbersService._serviceName$1);
NumbersService.TicketStates.preProcess = 0;
NumbersService.TicketStates.confirmationRequired = 1;
NumbersService.TicketStates.accepted = 2;
NumbersService.TicketStates.acceptable = 3;
NumbersService.TicketStates.rejected = 4;
NumbersService.TicketStates.waiting = 5;

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------
Type.createNamespace('BettingNavigationService');

////////////////////////////////////////////////////////////////////////////////
// BettingNavigationService.INextOfMarketGroupLoadedListener

BettingNavigationService.INextOfMarketGroupLoadedListener = function() { };
BettingNavigationService.INextOfMarketGroupLoadedListener.prototype = {
    onNextOfMarketGroupLoaded : null
}
BettingNavigationService.INextOfMarketGroupLoadedListener.createInterface('BettingNavigationService.INextOfMarketGroupLoadedListener');


////////////////////////////////////////////////////////////////////////////////
// BettingNavigationService.BettingNavigationService

BettingNavigationService.BettingNavigationService = function BettingNavigationService_BettingNavigationService() {
    this._validNavigationTypeActions$1 = new Array(0);
    this._validPageAreas$1 = [ 'betting' ];
    this._nextOffMarketGroupLoadedListners$1 = new Framework.ListenerInvoker(true);
    BettingNavigationService.BettingNavigationService.constructBase(this);
    BettingNavigationService.BettingNavigationService._log$1.debug('ctor');
    this._selectedTabs$1 = {};
}
BettingNavigationService.BettingNavigationService.prototype = {
    _defaultPageArea$1: 'betting',
    _nextOffMarketGroupID$1: null,
    _selectedTabs$1: null,
    _navigationService$1: null,
    
    setNavigationService: function BettingNavigationService_BettingNavigationService$setNavigationService(navigationService) {
        BettingNavigationService.BettingNavigationService._log$1.debug('NavigationService');
        this._navigationService$1 = navigationService;
    },
    
    init: function BettingNavigationService_BettingNavigationService$init(environment, parameters) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('Init parameters=[{0}]', Framework.DictionaryUtil.dumpToString(parameters)));
        BettingNavigationService.BettingNavigationService.callBase(this, 'init', [ environment, parameters ]);
        if (!String.isNullOrEmpty(parameters['default-page-area'])) {
            this._defaultPageArea$1 = (parameters['default-page-area']).toLowerCase();
        }
        if (!String.isNullOrEmpty(parameters['valid-page-areas'])) {
            this._validPageAreas$1 = (parameters['valid-page-areas']).toLowerCase().split(',');
        }
        if (!String.isNullOrEmpty(parameters['valid-navigation-type-actions'])) {
            this._validNavigationTypeActions$1 = (parameters['valid-navigation-type-actions']).toUpperCase().split(',');
        }
        this._environment.registerPageWillChangeListener(this);
        var state = this._environment.getStoredState(BettingNavigationService.BettingNavigationService._serviceName$1);
        if (state) {
            this._setState$1(state);
        }
    },
    
    start: function BettingNavigationService_BettingNavigationService$start() {
        BettingNavigationService.BettingNavigationService._log$1.debug('Start');
    },
    
    get_nextOffMarketGroupID: function BettingNavigationService_BettingNavigationService$get_nextOffMarketGroupID() {
        return this._nextOffMarketGroupID$1;
    },
    set_nextOffMarketGroupID: function BettingNavigationService_BettingNavigationService$set_nextOffMarketGroupID(value) {
        this._nextOffMarketGroupID$1 = value;
        return value;
    },
    
    get_activeMarketGroup: function BettingNavigationService_BettingNavigationService$get_activeMarketGroup() {
        if (this._navigationService$1.getPageFilter()[BettingNavigationService.BettingNavigationService.marketGroup]) {
            return this._navigationService$1.getPageFilter()[BettingNavigationService.BettingNavigationService.marketGroup];
        }
        if (!String.isNullOrEmpty(this.get_nextOffMarketGroupID())) {
            return this.get_nextOffMarketGroupID();
        }
        return null;
    },
    
    _getState$1: function BettingNavigationService_BettingNavigationService$_getState$1() {
        return { selectedTabs: this._selectedTabs$1 };
    },
    
    _setState$1: function BettingNavigationService_BettingNavigationService$_setState$1(state) {
        this._selectedTabs$1 = state['selectedTabs'];
    },
    
    setSelectedTab: function BettingNavigationService_BettingNavigationService$setSelectedTab(tabContainerID, tabID) {
        this._selectedTabs$1[tabContainerID] = tabID;
    },
    
    getSelectedTab: function BettingNavigationService_BettingNavigationService$getSelectedTab(tabContainerID) {
        if (Object.keyExists(this._selectedTabs$1, tabContainerID)) {
            return this._selectedTabs$1[tabContainerID];
        }
        return null;
    },
    
    _goTo$1: function BettingNavigationService_BettingNavigationService$_goTo$1(pageFilter) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('GoTo pageFilter=[{0}]', Framework.DictionaryUtil.dumpToString(pageFilter)));
        this._navigationService$1.goTo(this._currentBettingPageArea$1(), pageFilter);
    },
    
    _currentBettingPageArea$1: function BettingNavigationService_BettingNavigationService$_currentBettingPageArea$1() {
        var pageArea = this._navigationService$1.getPageArea();
        if (!this._validPageAreas$1.contains(pageArea.toLowerCase())) {
            pageArea = this._defaultPageArea$1;
        }
        return pageArea;
    },
    
    _calculateBONavigation$1: function BettingNavigationService_BettingNavigationService$_calculateBONavigation$1(pageFilter) {
        if (Object.keyExists(pageFilter, BettingNavigationService.BettingNavigationService.boNavigation)) {
            return (pageFilter[BettingNavigationService.BettingNavigationService.boNavigation]).split(',');
        }
        else {
            return [];
        }
    },
    
    _setBONavigation$1: function BettingNavigationService_BettingNavigationService$_setBONavigation$1(level, IDFWBONavigation, pageFilter) {
        if (!pageFilter) {
            pageFilter = this._navigationService$1.getPageFilter();
        }
        var oldBONavigation = this._calculateBONavigation$1(pageFilter);
        var newBONavigation = String.Empty;
        if (oldBONavigation.length < level) {
            throw new Error(String.format('Level [{0}] too large, current level is only [{1}]', level, oldBONavigation.length));
        }
        for (var i = 0; i < level; i++) {
            newBONavigation += oldBONavigation[i] + (((i < level - 1) || !String.isNullOrEmpty(IDFWBONavigation)) ? ',' : '');
        }
        if (!String.isNullOrEmpty(IDFWBONavigation)) {
            newBONavigation += IDFWBONavigation;
        }
        pageFilter[BettingNavigationService.BettingNavigationService.boNavigation] = newBONavigation;
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketGroup];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
        delete pageFilter[BettingNavigationService.BettingNavigationService.event];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        return pageFilter;
    },
    
    getBONavigation: function BettingNavigationService_BettingNavigationService$getBONavigation() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetBONavigation');
        return this._calculateBONavigation$1(this._navigationService$1.getPageFilter());
    },
    
    getValidNavigationTypeActions: function BettingNavigationService_BettingNavigationService$getValidNavigationTypeActions() {
        return this._validNavigationTypeActions$1;
    },
    
    getLastNodeInNavigation: function BettingNavigationService_BettingNavigationService$getLastNodeInNavigation() {
        if ((this.getBONavigation()) && (this.getBONavigation().length > 1)) {
            return this.getBONavigation()[this.getBONavigation().length - 1];
        }
        return 'top';
    },
    
    getNodeFromXML: function BettingNavigationService_BettingNavigationService$getNodeFromXML(node) {
        if (!node) {
            return null;
        }
        var returnNode = new BettingNavigationService.BoNavigationNode();
        returnNode.id = node.selectSingleNode('idfwbonavigation').text;
        returnNode.navigationTypes = node.selectSingleNode('idfwbonavigationtype').text;
        return returnNode;
    },
    
    setBONavigation: function BettingNavigationService_BettingNavigationService$setBONavigation(level, IDFWBONavigation) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetBONavigation level=[{0}] IDFWBONavigation=[{1}]', level, IDFWBONavigation));
        var pageFilter = this._setBONavigation$1(level, IDFWBONavigation, null);
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    setBONavigationLevels: function BettingNavigationService_BettingNavigationService$setBONavigationLevels(IDFWBONavigationLevels) {
        BettingNavigationService.BettingNavigationService._log$1.debug('SetBONavigationLevels');
        var pageFilter = null;
        for (var level = 0; level < IDFWBONavigationLevels.length; level++) {
            pageFilter = this._setBONavigation$1(level, IDFWBONavigationLevels[level], pageFilter);
        }
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    getMarketGroup: function BettingNavigationService_BettingNavigationService$getMarketGroup() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetMarketGroup');
        var pageFilter = this._navigationService$1.getPageFilter();
        return pageFilter[BettingNavigationService.BettingNavigationService.marketGroup];
    },
    
    setMarketGroup: function BettingNavigationService_BettingNavigationService$setMarketGroup(level, IDFWMarketGroup) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetMarketGroup level=[{0}] IDFWMarketGroup=[{1}]', level, IDFWMarketGroup));
        var pageFilter = this._navigationService$1.getPageFilter();
        var oldBONavigation = this._calculateBONavigation$1(pageFilter);
        var newBONavigation = String.Empty;
        for (var i = 0; i < Math.min(level, oldBONavigation.length); i++) {
            newBONavigation += oldBONavigation[i] + ((i < level - 1) ? ',' : '');
        }
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
        delete pageFilter[BettingNavigationService.BettingNavigationService.event];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        pageFilter[BettingNavigationService.BettingNavigationService.boNavigation] = newBONavigation;
        pageFilter[BettingNavigationService.BettingNavigationService.marketGroup] = IDFWMarketGroup;
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    fireNextOfMarketGroupLoadedEvent: function BettingNavigationService_BettingNavigationService$fireNextOfMarketGroupLoadedEvent(marketgroup) {
        BettingNavigationService.BettingNavigationService._log$1.debug('FireNextOfMarketGroupLoaded');
        this._nextOffMarketGroupID$1 = marketgroup;
        this._nextOffMarketGroupLoadedListners$1.fireUpdateEvent(Delegate.create(this, function(listener) {
            (listener).onNextOfMarketGroupLoaded(marketgroup);
        }));
    },
    
    registerNextOfMarketGroupLoadedListener: function BettingNavigationService_BettingNavigationService$registerNextOfMarketGroupLoadedListener(nextOfMarketGroupLoadedListener) {
        BettingNavigationService.BettingNavigationService._log$1.debug('RegisterNextOfMarketGroupLoadedListener');
        this._nextOffMarketGroupLoadedListners$1.registerListener(nextOfMarketGroupLoadedListener);
    },
    
    getMarketFromMarketGroup: function BettingNavigationService_BettingNavigationService$getMarketFromMarketGroup() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetMarketFromMarketGroup');
        var pageFilter = this._navigationService$1.getPageFilter();
        return pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
    },
    
    setMarketFromMarketGroup: function BettingNavigationService_BettingNavigationService$setMarketFromMarketGroup(IDFOMarket) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetMarketFromMarketGroup IDFOMarket=[{0}]', IDFOMarket));
        var pageFilter = this._navigationService$1.getPageFilter();
        delete pageFilter[BettingNavigationService.BettingNavigationService.event];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        if (String.isNullOrEmpty(IDFOMarket)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup] = IDFOMarket;
        }
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    getEvent: function BettingNavigationService_BettingNavigationService$getEvent() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetEvent');
        var pageFilter = this._navigationService$1.getPageFilter();
        return pageFilter[BettingNavigationService.BettingNavigationService.event];
    },
    
    setEvent: function BettingNavigationService_BettingNavigationService$setEvent(IDFOEvent, IDFOMarket, IDFWMarketGroup) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetEvent IDFOEvent=[{0}] IDFOMarket=[{1}] IDFWMarketGroup=[{2}] ', IDFOEvent, IDFOMarket, IDFWMarketGroup));
        var pageFilter = this._navigationService$1.getPageFilter();
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        if (!String.isNullOrEmpty(IDFOMarket)) {
            pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup] = IDFOMarket;
        }
        if (!String.isNullOrEmpty(IDFWMarketGroup)) {
            pageFilter[BettingNavigationService.BettingNavigationService.marketGroup] = IDFWMarketGroup;
        }
        pageFilter[BettingNavigationService.BettingNavigationService.event] = IDFOEvent;
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    getMarketFromEvent: function BettingNavigationService_BettingNavigationService$getMarketFromEvent() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetMarketFromEvent');
        var pageFilter = this._navigationService$1.getPageFilter();
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        return pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
    },
    
    setMarketFromEvent: function BettingNavigationService_BettingNavigationService$setMarketFromEvent(IDFOMarket) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetMarketFromEvent IDFOMarket=[{0}]', IDFOMarket));
        var pageFilter = this._navigationService$1.getPageFilter();
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        if (String.isNullOrEmpty(IDFOMarket)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent] = IDFOMarket;
        }
        pageFilter[NavigationService.NavigationService.action] = BettingNavigationService.BettingNavigationService._marketGroupListAction$1;
        this._goTo$1(pageFilter);
    },
    
    getEventScorecastFromEvent: function BettingNavigationService_BettingNavigationService$getEventScorecastFromEvent() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetEventScorecastFromEvent');
        var pageFilter = this._navigationService$1.getPageFilter();
        return pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
    },
    
    setEventScorecastFromEvent: function BettingNavigationService_BettingNavigationService$setEventScorecastFromEvent(IDFOEventScorecast) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetEventScorecastFromEvent IDFOEventScorecast=[{0}]', IDFOEventScorecast));
        var pageFilter = this._navigationService$1.getPageFilter();
        delete pageFilter[BettingNavigationService.BettingNavigationService.phrase];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        if (String.isNullOrEmpty(IDFOEventScorecast)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent] = IDFOEventScorecast;
        }
        this._goTo$1(pageFilter);
    },
    
    getSearchPhrase: function BettingNavigationService_BettingNavigationService$getSearchPhrase() {
        BettingNavigationService.BettingNavigationService._log$1.debug('GetPhrase');
        var pageFilter = this._navigationService$1.getPageFilter();
        return pageFilter[BettingNavigationService.BettingNavigationService.phrase];
    },
    
    setSearchPhrase: function BettingNavigationService_BettingNavigationService$setSearchPhrase(phrase, pageArea, action) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetPhrase phrase=[{0}]', phrase));
        var pageFilter = this._navigationService$1.getPageFilter();
        delete pageFilter[BettingNavigationService.BettingNavigationService.boNavigation];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketGroup];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
        delete pageFilter[BettingNavigationService.BettingNavigationService.event];
        delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        pageFilter[BettingNavigationService.BettingNavigationService.phrase] = phrase;
        pageFilter[NavigationService.NavigationService.action] = action;
        this._navigationService$1.goTo(pageArea, pageFilter);
    },
    
    getNavigationTypes: function BettingNavigationService_BettingNavigationService$getNavigationTypes() {
        var pageFilter = this._navigationService$1.getPageFilter();
        if (!pageFilter[BettingNavigationService.BettingNavigationService.navigationTypes]) {
            return null;
        }
        return (pageFilter[BettingNavigationService.BettingNavigationService.navigationTypes]).toUpperCase();
    },
    
    removeInvalidNavigationTypes: function BettingNavigationService_BettingNavigationService$removeInvalidNavigationTypes(navigationTypesAsString) {
        if (!navigationTypesAsString) {
            return String.Empty;
        }
        var navigationTypes = navigationTypesAsString.split(',');
        var returnValue = '';
        for (var count = 0; count < navigationTypes.length; count++) {
            if (this.getValidNavigationTypeActions().contains(navigationTypes[count])) {
                if ((count > 0) && (returnValue.length > 0)) {
                    returnValue += ',';
                }
                returnValue += navigationTypes[count];
            }
        }
        return returnValue;
    },
    
    setNavigationTypes: function BettingNavigationService_BettingNavigationService$setNavigationTypes(navigationTypes) {
        var clonedPageFilter = {};
        var _pageFilter = this._navigationService$1.getPageFilter();
        var $dict1 = _pageFilter;
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            if (String.compare(entry.key, BettingNavigationService.BettingNavigationService.navigationTypes, true)) {
                clonedPageFilter[entry.key] = entry.value;
            }
        }
        if (navigationTypes) {
            navigationTypes = navigationTypes.toUpperCase();
            clonedPageFilter[BettingNavigationService.BettingNavigationService.navigationTypes] = navigationTypes;
        }
        this._goTo$1(clonedPageFilter);
    },
    
    loadNextOffMarketGroupID: function BettingNavigationService_BettingNavigationService$loadNextOffMarketGroupID(bonavigationid, navigationtype) {
        var url = '/cache/boyleSportsNextOffMarketGroup/${region}/${language}/${navigationtype}/${bonavigationid}.xml';
        url = url.replace('${region}', this._environment.getRegion());
        url = url.replace('${language}', this._environment.getLanguage());
        url = url.replace('${navigationtype}', navigationtype);
        url = url.replace('${bonavigationid}', bonavigationid);
        var contentRequest = new Framework.XMLHttpRequestDecorator();
        contentRequest.onreadystatechange = Delegate.create(this, function() {
            if (contentRequest.status === 200 || contentRequest.status === 304) {
                var node = contentRequest.responseXML.selectSingleNode('/MarketGroup/idfwmarketgroup');
                if (node) {
                    var nextOffMarketGroupID = node.text;
                    this.fireNextOfMarketGroupLoadedEvent(nextOffMarketGroupID);
                }
            }
        });
        contentRequest.open('GET', url, true);
        contentRequest.send(null);
        return contentRequest.responseXML;
    },
    
    loadAndSetNavigationFromMarket: function BettingNavigationService_BettingNavigationService$loadAndSetNavigationFromMarket(navigationid, marketID, pageFilter, callback) {
        var url = '/cache/boNavigationLookupWithMarket/${region}/${language}/${bonavigationid}/${marketid}.xml';
        url = url.replace('${region}', this._environment.getRegion());
        url = url.replace('${language}', this._environment.getLanguage());
        url = url.replace('${bonavigationid}', this.getLastNodeInNavigation());
        url = url.replace('${marketid}', marketID);
        var contentRequest = new Framework.XMLHttpRequestDecorator();
        contentRequest.onreadystatechange = Delegate.create(this, function() {
            if (contentRequest.status === 200 || contentRequest.status === 304) {
                callback.invoke(pageFilter, contentRequest.responseXML);
            }
        });
        contentRequest.open('GET', url, true);
        contentRequest.send(null);
        return contentRequest.responseXML;
    },
    
    loadAndSetNavigationFromMarketGroup: function BettingNavigationService_BettingNavigationService$loadAndSetNavigationFromMarketGroup(navigationid, marketgroupID, pageFilter, callback) {
        var url = '/cache/boNavigationLookupWithMarketGroup/${region}/${language}/${bonavigationid}/${marketgroupid}.xml';
        url = url.replace('${region}', this._environment.getRegion());
        url = url.replace('${language}', this._environment.getLanguage());
        url = url.replace('${bonavigationid}', navigationid);
        url = url.replace('${marketgroupid}', marketgroupID);
        var contentRequest = new Framework.XMLHttpRequestDecorator();
        contentRequest.onreadystatechange = Delegate.create(this, function() {
            if (contentRequest.status === 200 || contentRequest.status === 304) {
                callback.invoke(pageFilter, contentRequest.responseXML);
            }
        });
        contentRequest.open('GET', url, true);
        contentRequest.send(null);
        return contentRequest.responseXML;
    },
    
    loadAndSetNavigationFromEventID: function BettingNavigationService_BettingNavigationService$loadAndSetNavigationFromEventID(navigationid, eventID, pageFilter, callback) {
        var url = '/cache/boNavigationLookupWithEvent/${region}/${language}/${bonavigationid}/${eventid}.xml';
        url = url.replace('${region}', this._environment.getRegion());
        url = url.replace('${language}', this._environment.getLanguage());
        url = url.replace('${bonavigationid}', this.getLastNodeInNavigation());
        url = url.replace('${eventid}', eventID);
        var contentRequest = new Framework.XMLHttpRequestDecorator();
        contentRequest.onreadystatechange = Delegate.create(this, function() {
            if (contentRequest.status === 200 || contentRequest.status === 304) {
                callback.invoke(pageFilter, contentRequest.responseXML);
            }
        });
        contentRequest.open('GET', url, true);
        contentRequest.send(null);
        return contentRequest.responseXML;
    },
    
    getPageActionFromNavigationTypes: function BettingNavigationService_BettingNavigationService$getPageActionFromNavigationTypes(navigationTypes) {
        return '';
    },
    
    setNavigation: function BettingNavigationService_BettingNavigationService$setNavigation(IDFWBONavigation, IDFWMarketGroup, IDFOMarketFromMarketGroup, IDFOEvent, IDFOMarketFromEvent, IDFOEventScorecastFromEvent) {
        this.setNavigationWithAction(IDFWBONavigation, IDFWMarketGroup, IDFOMarketFromMarketGroup, IDFOEvent, IDFOMarketFromEvent, IDFOEventScorecastFromEvent, BettingNavigationService.BettingNavigationService._marketGroupListAction$1, null);
    },
    
    setNavigationWithAction: function BettingNavigationService_BettingNavigationService$setNavigationWithAction(IDFWBONavigation, IDFWMarketGroup, IDFOMarketFromMarketGroup, IDFOEvent, IDFOMarketFromEvent, IDFOEventScorecastFromEvent, action, navigationTypes) {
        BettingNavigationService.BettingNavigationService._log$1.debug(String.format('SetNavigation IDFWBONavigation=[{0}] IDFWMarketGroup=[{1}] IDFOMarketFromMarketGroup=[{2}] IDFOEvent=[{3}] IDFOMarketFromEvent=[{4}] IDFOEventScorecastFromEvent=[{5}]', IDFWBONavigation, IDFWMarketGroup, IDFOMarketFromMarketGroup, IDFOEvent, IDFOMarketFromEvent, IDFOEventScorecastFromEvent));
        var pageFilter = this._navigationService$1.getPageFilter();
        pageFilter[BettingNavigationService.BettingNavigationService.showAllMarkets] = null;
        if (!IDFWBONavigation) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.boNavigation];
        }
        else {
            var navigation = '';
            for (var i = 0; i < IDFWBONavigation.length; i++) {
                navigation += IDFWBONavigation[i] + ((i < IDFWBONavigation.length - 1) ? ',' : '');
            }
            pageFilter[BettingNavigationService.BettingNavigationService.boNavigation] = navigation;
        }
        if (String.isNullOrEmpty(IDFWMarketGroup)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.marketGroup];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.marketGroup] = IDFWMarketGroup;
        }
        if (String.isNullOrEmpty(IDFOMarketFromMarketGroup)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.marketFromMarketGroup] = IDFOMarketFromMarketGroup;
        }
        if (String.isNullOrEmpty(IDFOEvent)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.event];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.event] = IDFOEvent;
        }
        if (String.isNullOrEmpty(IDFOMarketFromEvent)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.marketFromEvent] = IDFOMarketFromEvent;
        }
        if (String.isNullOrEmpty(IDFOEventScorecastFromEvent)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.eventScorecastFromEvent] = IDFOEventScorecastFromEvent;
        }
        if (String.isNullOrEmpty(action)) {
            delete pageFilter[NavigationService.NavigationService.action];
        }
        else {
            pageFilter[NavigationService.NavigationService.action] = action;
        }
        if (String.isNullOrEmpty(navigationTypes)) {
            delete pageFilter[BettingNavigationService.BettingNavigationService.navigationTypes];
        }
        else {
            pageFilter[BettingNavigationService.BettingNavigationService.navigationTypes] = navigationTypes.toUpperCase();
        }
        this._goTo$1(pageFilter);
    },
    
    onPageWillChange: function BettingNavigationService_BettingNavigationService$onPageWillChange() {
        this._environment.storeState(BettingNavigationService.BettingNavigationService._serviceName$1, this._getState$1());
    }
}


////////////////////////////////////////////////////////////////////////////////
// BettingNavigationService.BoNavigationNode

BettingNavigationService.BoNavigationNode = function BettingNavigationService_BoNavigationNode() {
}
BettingNavigationService.BoNavigationNode.prototype = {
    navigationTypes: null,
    id: null
}


BettingNavigationService.BettingNavigationService.createClass('BettingNavigationService.BettingNavigationService', Framework.AbstractService, Framework.IPageWillChangeListener);
BettingNavigationService.BoNavigationNode.createClass('BettingNavigationService.BoNavigationNode');
BettingNavigationService.BettingNavigationService._serviceName$1 = 'BettingNavigationService';
BettingNavigationService.BettingNavigationService._log$1 = Framework.Logger.getLog(BettingNavigationService.BettingNavigationService._serviceName$1);
BettingNavigationService.BettingNavigationService.boNavigation = 'bo-navigation';
BettingNavigationService.BettingNavigationService.marketGroup = 'market-group';
BettingNavigationService.BettingNavigationService.marketFromMarketGroup = 'market-mg';
BettingNavigationService.BettingNavigationService.event = 'event';
BettingNavigationService.BettingNavigationService.marketFromEvent = 'market-e';
BettingNavigationService.BettingNavigationService.eventScorecastFromEvent = 'eventscorecast-e';
BettingNavigationService.BettingNavigationService.phrase = 'phrase';
Bett