var aspss = {};

aspss["engine"] = {
    version: "4.0"
};

aspss["Class"] = function(properties) {
    var klass = function() {
        if (arguments[0] !== null && this["initialize"] && aspss.$type(this["initialize"]) == "function") {
            return this["initialize"]["apply"](this, arguments);
        } else {
            return this;
        };
    };
    aspss.$extend(klass, this);
    klass["prototype"] = properties;
    return klass;
};
aspss["Class"]["empty"] = function() {};
aspss["Class"]["prototype"] = {
    extend: function(properties) {
        var proto = new this(null);
        for (var property in properties) {
            var pp = proto[property];
            proto[property] = aspss.$mergeClass(pp, properties[property]);
        };
        return new aspss.Class(proto);
    },
    implement: function(properties) {
        aspss.$extend(this["prototype"], properties);
    }
};
aspss["$type"] = function(obj) {
    if (obj == undefined) {
        return false;
    };
    var type = typeof obj;
    if (type == "object") {
        if (obj["htmlElement"]) {
            return "element";
        };
        if (obj["push"]) {
            return "array";
        };
        if (obj["nodeName"]) {
            switch (obj["nodeType"]) {
            case 1:
                return "element";;
            case 3:
                return obj["nodeValue"]["test"](/\S/) ? "textnode": "whitespace";;
            };
        };
    };
    if ((type == "object" || type == "function") && obj["exec"]) {
        return "regexp";
    };
    return type;
};
aspss["$merge"] = function() {
    var mix = {};
    for (var i = 0; i < arguments["length"]; i++) {
        for (var property in arguments[i]) {
            var ap = arguments[i][property];
            var mp = mix[property];
            if (mp && aspss.$type(ap) == "object" && aspss.$type(mp) == "object") {
                mix[property] = aspss.$merge(mp, ap);
            } else {
                mix[property] = ap;
            };
        };
    };
    return mix;
};
aspss["$mergeClass"] = function(previous, current) {
    if (previous && previous != current) {
        var ptype = aspss.$type(previous);
        var ctype = aspss.$type(current);
        if (ptype == "function" && ctype == "function") {
            var merged = function() {
                this["parent"] = arguments["callee"]["parent"];
                return current["apply"](this, arguments);
            };
            merged["parent"] = previous;
            return merged;
        } else {
            if (ptype == "object" && ctype == "object") {
                return aspss.$merge(previous, current);
            };
        };
    };
    return current;
};
aspss["$extend"] = Object["extend"] = function() {
    var args = arguments;
    if (!args[1]) {
        args = [this, args[0]];
    };
    for (var property in args[1]) {
        args[0][property] = args[1][property];
    };
    return args[0];
};
aspss["$native"] = Object["Native"] = function() {
    for (var i = 0; i < arguments["length"]; i++) {
        arguments[i]["extend"] = aspss["$native"]["extend"];
    };
};
aspss["$native"]["extend"] = function(props) {
    for (var prop in props) {
        if (!this["prototype"][prop]) {
            this["prototype"][prop] = props[prop];
        };
    };
};
aspss.$native(Function, Array, String, Number, aspss.Class);
aspss["Abstract"] = function(obj) {
    obj = obj || {};
    obj["extend"] = aspss["$extend"];
    return obj;
};
aspss["Window"] = new aspss.Abstract(window);
aspss["Document"] = new aspss.Abstract(document);
document["head"] = document["getElementsByTagName"]("head")[0];
aspss["$chk"] = function(obj) {
    return !! (obj || obj === 0);
};
aspss["$pick"] = function(obj, picked) {
    return (obj != undefined) ? obj: picked;
};
aspss["$random"] = function(min, max) {
    return Math["floor"](Math["random"]() * (max - min + 1) + min);
};
aspss["$time"] = function() {
    return new Date()["getTime"]();
};
aspss["$clear"] = function(timer) {
    clearTimeout(timer);
    clearInterval(timer);
    return null;
};
if (window["ActiveXObject"]) {
    window["ie"] = window[window["XMLHttpRequest"] ? "ie7": "ie6"] = true;
} else {
    if (document["childNodes"] && !document["all"] && !navigator["taintEnabled"]) {
        window["khtml"] = true;
    } else {
        if (document["getBoxObjectFor"] != null) {
            window["gecko"] = true;
        };
    };
};
window["xpath"] = !!(document["evaluate"]);
if (typeof HTMLElement == "undefined") {
    var HTMLElement = aspss["Class"]["empty"];
    if (window["khtml"]) {
        document["createElement"]("iframe");
    };
    HTMLElement["prototype"] = (window["khtml"]) ? window["[[DOMElement.prototype]]"] : {};
};
HTMLElement["prototype"]["htmlElement"] = true;
if (window["ie6"]) {
    try {
        document["execCommand"]("BackgroundImageCache", false, true);
    } catch(e) {};
};



/*           OKR Chain      1199   */

aspss["Chain"] = new aspss.Class({
    chain: function(fn) {
        this["chains"] = this["chains"] || [];
        this["chains"]["push"](fn);
        return this;
    },
    callChain: function() {
        if (this["chains"] && this["chains"]["length"]) {
            this["chains"]["shift"]()["delay"](10, this);
        };
    },
    clearChain: function() {
        this["chains"] = [];
    }
});


/*         OKR  Events    1220    */            
aspss["Events"] = new aspss.Class({
    addEvent: function(type, fn) {
        if (fn != aspss["Class"]["empty"]) {
            this["$events"] = this["$events"] || {};
            this["$events"][type] = this["$events"][type] || [];
            this["$events"][type]["include"](fn);
        };
        return this;
    },
    fireEvent: function(type, args, delay) {
        if (this["$events"] && this["$events"][type]) {
            this["$events"][type]["each"](function(fn) {
                fn["create"]({
                    "bind": this,
                    "delay": delay,
                    "arguments": args
                })();
            },
            this);
        };
        return this;
    },
    removeEvent: function(type, fn) {
        if (this["$events"] && this["$events"][type]) {
            this["$events"][type]["remove"](fn);
        };
        return this;
    }
});



//        OKR Options      1278  */
aspss["Options"] = new aspss.Class({
    setOptions: function() {
        var args = (arguments["length"] == 1) ? [this["options"], arguments[0]] : arguments;
        this["options"] = aspss["$merge"]["apply"](this, args);
        if (this["addEvent"]) {
            for (var option in this["options"]) {
                if ((aspss.$type(this["options"][option]) == "function") && option["test"](/^on[A-Z]/)) {
                    this["addEvent"](option, this["options"][option]);
                };
            };
        };
        return this;
    }
});
Array["extend"]({
    forEach: function(fn, bind) {
        for (var i = 0, j = this["length"]; i < j; i++) {
            fn["call"](bind, this[i], i, this);
        };
    },
    filter: function(fn, bind) {
        var results = [];
        for (var i = 0, j = this["length"]; i < j; i++) {
            if (fn["call"](bind, this[i], i, this)) {
                results["push"](this[i]);
            };
        };
        return results;
    },
    map: function(fn, bind) {
        var results = [];
        for (var i = 0, j = this["length"]; i < j; i++) {
            results[i] = fn["call"](bind, this[i], i, this);
        };
        return results;
    },
    every: function(fn, bind) {
        for (var i = 0, j = this["length"]; i < j; i++) {
            if (!fn["call"](bind, this[i], i, this)) {
                return false;
            };
        };
        return true;
    },
    some: function(fn, bind) {
        for (var i = 0, j = this["length"]; i < j; i++) {
            if (fn["call"](bind, this[i], i, this)) {
                return true;
            };
        };
        return false;
    },
    indexOf: function(item, from) {
        var len = this["length"];
        for (var i = (from < 0) ? Math["max"](0, len + from) : from || 0; i < len; i++) {
            if (this[i] === item) {
                return i;
            };
        };
        return - 1;
    },
    copy: function(start, length) {
        start = start || 0;
        if (start < 0) {
            start = this["length"] + start;
        };
        length = length || (this["length"] - start);
        var newArray = [];
        for (var i = 0; i < length; i++) {
            newArray[i] = this[start++];
        };
        return newArray;
    },
    remove: function(item) {
        var i = 0;
        var len = this["length"];
        while (i < len) {
            if (this[i] === item) {
                this["splice"](i, 1);
                len--;
            } else {
                i++;
            };
        };
        return this;
    },
    contains: function(item, from) {
        return this["indexOf"](item, from) != -1;
    },
    associate: function(keys) {
        var obj = {},
        length = Math["min"](this["length"], keys["length"]);
        for (var i = 0; i < length; i++) {
            obj[keys[i]] = this[i];
        };
        return obj;
    },
    extend: function(array) {
        for (var i = 0, j = array["length"]; i < j; i++) {
            this["push"](array[i]);
        };
        return this;
    },
    merge: function(array) {
        for (var i = 0, l = array["length"]; i < l; i++) {
            this["include"](array[i]);
        };
        return this;
    },
    include: function(item) {
        if (!this["length"] || !this["contains"](item)) {
            this["push"](item);
        };
        return this;
    },
    getRandom: function() {
        return this[aspss.$random(0, this["length"] - 1)];
    },
    getLast: function() {
        return this[this["length"] - 1];
    }
});
Array["prototype"]["each"] = Array["prototype"]["forEach"];
Array["prototype"]["test"] = Array["prototype"]["contains"];
Array["prototype"]["removeItem"] = Array["prototype"]["remove"];
aspss["$A"] = function(array, start, length) {
    return Array["prototype"]["copy"]["call"](array, start, length);
};
aspss["$each"] = function(iterable, fn, bind) {
    if (iterable["length"] != undefined) {
        Array["prototype"]["forEach"]["call"](iterable, fn, bind);
    } else {
        for (var name in iterable) {
            fn["call"](bind || iterable, iterable[name], name);
        };
    };
};
String["extend"]({
    test: function(regex, params) {
        return ((typeof regex == "string") ? new RegExp(regex, params) : regex)["test"](this);
    },
    toInt: function() {
        return parseInt(this, 10);
    },
    toFloat: function() {
        return parseFloat(this);
    },
    camelCase: function() {
        return this["replace"](/-\D/g,
        function(match) {
            return match["charAt"](1)["toUpperCase"]();
        });
    },
    hyphenate: function() {
        return this["replace"](/\w[A-Z]/g,
        function(match) {
            return (match["charAt"](0) + "-" + match["charAt"](1)["toLowerCase"]());
        });
    },
    capitalize: function() {
        return this["replace"](/\b[a-z]/g,
        function(match) {
            return match["toUpperCase"]();
        });
    },
    trim: function() {
        return this["replace"](/^\s+|\s+$/g, "");
    },
    clean: function() {
        return this["replace"](/\s{2,}/g, " ")["trim"]();
    },
    rgbToHex: function(array) {
        var rgb = this["match"](/\d{1,3}/g);
        return (rgb) ? rgb["rgbToHex"](array) : false;
    },
    hexToRgb: function(array) {
        var hex = this["match"](/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
        return (hex) ? hex["slice"](1)["hexToRgb"](array) : false;
    },
    contains: function(string, s) {
        return (s) ? (s + this + s)["indexOf"](s + string + s) > -1 : this["indexOf"](string) > -1;
    },
    escapeRegExp: function() {
        return this["replace"](/([.*+?^${}()|[\]\/\\])/g, "\x5C$1");
    }
});
Array["extend"]({
    rgbToHex: function(array) {
        if (this["length"] < 3) {
            return false;
        };
        if (this[3] && (this[3] == 0) && !array) {
            return "transparent";
        };
        var hex = [];
        for (var i = 0; i < 3; i++) {
            var bit = (this[i] - 0).toString(16);
            hex["push"]((bit["length"] == 1) ? "0" + bit: bit);
        };
        return array ? hex: "#" + hex["join"]("");
    },
    hexToRgb: function(array) {
        if (this["length"] != 3) {
            return false;
        };
        var rgb = [];
        for (var i = 0; i < 3; i++) {
            rgb["push"](parseInt((this[i]["length"] == 1) ? this[i] + this[i] : this[i], 16));
        };
        return array ? rgb: "rgb(" + rgb["join"](",") + ")";
    }
});
Number["extend"]({
    toInt: function() {
        return parseInt(this);
    },
    toFloat: function() {
        return parseFloat(this);
    }
});
Function["extend"]({
    create: function(options) {
        var fn = this;
        options = aspss.$merge({
            "bind": fn,
            "event": false,
            "arguments": null,
            "delay": false,
            "periodical": false,
            "attempt": false
        },
        options);
        if (aspss.$chk(options["arguments"]) && aspss.$type(options["arguments"]) != "array") {
            options["arguments"] = [options["arguments"]];
        };
        return function(event) {
            var args;
            if (options["event"]) {
                event = event || window["event"];
                args = [(options["event"] === true) ? event: new options["event"](event)];
                if (options["arguments"]) {
                    args = args["concat"](options["arguments"]);
                };
            } else {
                args = options["arguments"] || arguments;
            };
            var returns = function() {
                return fn["apply"](aspss.$pick(options["bind"], fn), args);
            };
            if (options["delay"]) {
                return setTimeout(returns, options["delay"]);
            };
            if (options["periodical"]) {
                return setInterval(returns, options["periodical"]);
            };
            if (options["attempt"]) {
                try {
                    return returns();
                } catch(err) {
                    return false;
                };
            };
            return returns();
        };
    },
    pass: function(args, bind) {
        return this["create"]({
            "arguments": args,
            "bind": bind
        });
    },
    attempt: function(args, bind) {
        return this["create"]({
            "arguments": args,
            "bind": bind,
            "attempt": true
        })();
    },
    bind: function(bind, args) {
        return this["create"]({
            "bind": bind,
            "arguments": args
        });
    },
    bindAsEventListener: function(bind, args) {
        return this["create"]({
            "bind": bind,
            "event": true,
            "arguments": args
        });
    },
    delay: function(delay, bind, args) {
        return this["create"]({
            "delay": delay,
            "bind": bind,
            "arguments": args
        })();
    },
    periodical: function(interval, bind, args) {
        return this["create"]({
            "periodical": interval,
            "bind": bind,
            "arguments": args
        })();
    }
});
aspss["Element"] = new aspss.Class({
    initialize: function(el, props) {
        if (aspss.$type(el) == "string") {
            if (window["ie"] && props && (props["name"] || props["type"])) {
                var name = (props["name"]) ? " name=\x22" + props["name"] + "\x22": "";
                var type = (props["type"]) ? " type=\x22" + props["type"] + "\x22": "";
                delete props["name"];
                delete props["type"];
                el = "\x3C" + el + name + type + "\x3E";
            };
            el = document["createElement"](el);
        };
        el = aspss.$(el);
        if (!props || !el) {
            return el;
        };
        for (var prop in props) {
            var val = props[prop];
            switch (prop) {
            case "styles":
                el["setStyles"](val);
                break;;
            case "events":
                if (el["addEvents"]) {
                    el["addEvents"](val);
                };
                break;;
            case "properties":
                el["setProperties"](val);
                break;;
            default:
                el["setProperty"](prop, val);;
            };
        };
        return el;
    }
});
aspss["Elements"] = new aspss.Class({});
aspss["Elements"]["extend"] = aspss["Class"]["prototype"]["implement"];
aspss["$"] = function(el) {
    if (!el) {
        return false;
    };
    if (el["htmlElement"]) {
        return aspss["Garbage"]["collect"](el);
    };
    if ([window, document]["contains"](el)) {
        return el;
    };
    var type = aspss.$type(el);
    if (type == "string") {
        el = document["getElementById"](el);
        type = (el) ? "element": false;
    };
    if (type != "element") {
        return false;
    };
    if (el["htmlElement"]) {
        return aspss["Garbage"]["collect"](el);
    };
    if (["object", "embed"]["contains"](el["tagName"]["toLowerCase"]())) {
        return el;
    };
    aspss.$extend(el, aspss["Element"]["prototype"]);
    el["htmlElement"] = true;
    return aspss["Garbage"]["collect"](el);
};
document["getElementsBySelector"] = document["getElementsByTagName"];
aspss["$$"] = function() {
    if (!arguments) {
        return false;
    };
    var elements = [];
    for (var i = 0, j = arguments["length"]; i < j; i++) {
        var selector = arguments[i];
        switch (aspss.$type(selector)) {
        case "element":
            elements["push"](selector);;
        case "boolean":
            ;
        case false:
            break;;
        case "string":
            selector = document["getElementsBySelector"](selector, true);;
        default:
            elements = elements["concat"]((selector["push"]) ? selector: aspss.$A(selector));;
        };
    };
    return aspss["$$"]["unique"](elements);
};
aspss["$$"]["unique"] = function(array) {
    var elements = [];
    for (var i = 0, l = array["length"]; i < l; i++) {
        if (array[i]["$included"]) {
            continue;
        };
        var element = aspss.$(array[i]);
        if (element && !element["$included"]) {
            element["$included"] = true;
            elements["push"](element);
        };
    };
    for (var i = 0, l = elements["length"]; i < l; i++) {
        elements[i]["$included"] = null;
    };
    return aspss.$extend(elements, new aspss.Elements);
};
aspss["Elements"]["Multi"] = function(property) {
    return function() {
        var args = arguments;
        var items = [];
        var elements = true;
        for (var i = 0, j = this["length"], returns; i < j; i++) {
            returns = this[i][property]["apply"](this[i], args);
            if (aspss.$type(returns) != "element") {
                elements = false;
            };
            items["push"](returns);
        };
        return (elements) ? aspss["$$"]["unique"](items) : items;
    };
};
aspss["Element"]["extend"] = function(properties) {
    for (var property in properties) {
        HTMLElement["prototype"][property] = properties[property];
        aspss["Element"]["prototype"][property] = properties[property];
        aspss["Elements"]["prototype"][property] = aspss["Elements"].Multi(property);
    };
};
aspss["Element"]["extend"]({
    inject: function(el, where) {
        el = aspss.$(el);
        switch (where) {
        case "before":
            el["parentNode"]["insertBefore"](this, el);
            break;;
        case "after":
            var next = el["getNext"]();
            if (!next) {
                el["parentNode"]["appendChild"](this);
            } else {
                el["parentNode"]["insertBefore"](this, next);
            };
            break;;
        case "top":
            var first = el["firstChild"];
            if (first) {
                el["insertBefore"](this, first);
                break;
            };;
        default:
            el["appendChild"](this);;
        };
        return this;
    },
    injectBefore: function(el) {
        return this["inject"](el, "before");
    },
    injectAfter: function(el) {
        return this["inject"](el, "after");
    },
    injectInside: function(el) {
        return this["inject"](el, "bottom");
    },
    injectTop: function(el) {
        return this["inject"](el, "top");
    },
    adopt: function() {
        aspss["$$"]["unique"](arguments)["injectInside"](this);
        return this;
    },
    remove: function() {
        return this["parentNode"]["removeChild"](this);
    },
    clone: function(contents) {
        return aspss.$(this["cloneNode"](contents !== false));
    },
    replaceWith: function(el) {
        el = aspss.$(el);
        this["parentNode"]["replaceChild"](el, this);
        return el;
    },
    appendText: function(text) {
        if (window["ie"]) {
            switch (this["getTag"]()) {
            case "style":
                this["styleSheet"]["cssText"] = text;
                return this;;
            case "script":
                return this["setProperty"]("text", text);;
            };
        };
        this["appendChild"](document["createTextNode"](text));
        return this;
    },
    hasClass: function(className) {
        return this["className"]["contains"](className, " ");
    },
    addClass: function(className) {
        if (!this["hasClass"](className)) {
            this["className"] = (this["className"] + " " + className)["clean"]();
        };
        return this;
    },
    removeClass: function(className) {
        this["className"] = this["className"]["replace"](new RegExp("(^|\x5Cs)" + className + "(?:\x5Cs|$)"), "$1")["clean"]();
        return this;
    },
    toggleClass: function(className) {
        return this["hasClass"](className) ? this["removeClass"](className) : this["addClass"](className);
    },
    setStyle: function(property, value) {
        switch (property) {
        case "opacity":
            return this["setOpacity"](parseFloat(value));;
        case "float":
            property = (window["ie"]) ? "styleFloat": "cssFloat";;
        };
        property = property["camelCase"]();
        switch (aspss.$type(value)) {
        case "number":
            if (! ["zIndex", "zoom"]["contains"](property)) {
                value += "px";
            };
            break;;
        case "array":
            value = "rgb(" + value["join"](",") + ")";;
        };
        this["style"][property] = value;
        return this;
    },
    setStyles: function(source) {
        switch (aspss.$type(source)) {
        case "object":
            aspss["Element"]["setMany"](this, "setStyle", source);
            break;;
        case "string":
            this["style"]["cssText"] = source;;
        };
        return this;
    },
    setOpacity: function(opacity) {
        if (opacity == 0) {
            if (this["style"]["visibility"] != "hidden") {
                this["style"]["visibility"] = "hidden";
            };
        } else {
            if (this["style"]["visibility"] != "visible") {
                this["style"]["visibility"] = "visible";
            };
        };
        if (!this["currentStyle"] || !this["currentStyle"]["hasLayout"]) {
            this["style"]["zoom"] = 1;
        };
        if (window["ie"]) {
            this["style"]["filter"] = (opacity == 1) ? "": "alpha(opacity=" + opacity * 100 + ")";
        };
        this["style"]["opacity"] = this["$"]["opacity"] = opacity;
        return this;
    },
    getStyle: function(property) {
        property = property["camelCase"]();
        var result = this["style"][property];
        if (!aspss.$chk(result)) {
            if (property == "opacity") {
                return this["$"]["opacity"];
            };
            var result = [];
            for (var style in aspss["Element"]["Styles"]) {
                if (property == style) {
                    aspss["Element"]["Styles"][style]["each"](function(s) {
                        result["push"](this["getStyle"](s));
                    },
                    this);
                    if (property == "border") {
                        var every = result["every"](function(bit) {
                            return (bit == result[0]);
                        });
                        return (every) ? result[0] : false;
                    };
                    return result["join"](" ");
                };
            };
            if (aspss["Element"]["Styles"]["border"]["contains"](property)) { ["Width", "aspss.Color", "Style"]["each"](function(p) {
                    result["push"](this["getStyle"](property + p));
                },
                this);
                return result["join"](" ");
            };
            if (document["defaultView"]) {
                result = document["defaultView"]["getComputedStyle"](this, null)["getPropertyValue"](property["hyphenate"]());
            } else {
                if (this["currentStyle"]) {
                    result = this["currentStyle"][property];
                };
            };
        };
        if (window["ie"]) {
            result = aspss["Element"]["fixStyle"](property, result, this);
        };
        return (result && property["test"](/color/i) && result["contains"]("rgb")) ? result["rgbToHex"]() : result;
    },
    getStyles: function() {
        return aspss["Element"]["getMany"](this, "getStyle", arguments);
    },
    walk: function(brother, start) {
        brother += "Sibling";
        var el = (start) ? this[start] : this[brother];
        while (el && aspss.$type(el) != "element") {
            el = el[brother];
        };
        return aspss.$(el);
    },
    getPrevious: function() {
        return this["walk"]("previous");
    },
    getNext: function() {
        return this["walk"]("next");
    },
    getFirst: function() {
        return this["walk"]("next", "firstChild");
    },
    getLast: function() {
        return this["walk"]("previous", "lastChild");
    },
    getParent: function() {
        return aspss.$(this["parentNode"]);
    },
    getChildren: function() {
        return aspss.$$(this["childNodes"]);
    },
    hasChild: function(el) {
        return !! aspss.$A(this["getElementsByTagName"]("*"))["contains"](el);
    },
    getProperty: function(property) {
        var index = aspss["Element"]["Properties"][property];
        return (index) ? this[index] : this["getAttribute"](property);
    },
    removeProperty: function(property) {
        var index = aspss["Element"]["Properties"][property];
        if (index) {
            this[index] = "";
        } else {
            this["removeAttribute"](property);
        };
        return this;
    },
    getProperties: function() {
        return aspss["Element"]["getMany"](this, "getProperty", arguments);
    },
    setProperty: function(property, value) {
        var index = aspss["Element"]["Properties"][property];
        if (index) {
            this[index] = value;
        } else {
            this["setAttribute"](property, value);
        };
        return this;
    },
    setProperties: function(source) {
        return aspss["Element"]["setMany"](this, "setProperty", source);
    },
    setHTML: function() {
        this["innerHTML"] = aspss.$A(arguments)["join"]("");
        return this;
    },
    getTag: function() {
        return this["tagName"]["toLowerCase"]();
    },
    empty: function() {
        aspss["Garbage"]["trash"](this["getElementsByTagName"]("*"));
        return this["setHTML"]("");
    }
});
aspss["Element"]["fixStyle"] = function(property, result, element) {
    if (aspss.$chk(parseInt(result))) {
        return result;
    };
    if (["height", "width"]["contains"](property)) {
        var values = (property == "width") ? ["left", "right"] : ["top", "bottom"];
        var size = 0;
        values["each"](function(value) {
            size += element["getStyle"]("border-" + value + "-width")["toInt"]() + element["getStyle"]("padding-" + value)["toInt"]();
        });
        return element["offset" + property["capitalize"]()] - size + "px";
    } else {
        if (property["test"](/border(.+)Width/)) {
            return "0px";
        };
    };
    return result;
};
aspss["Element"]["Styles"] = {
    "border": [],
    "padding": [],
    "margin": []
};
["Top", "Right", "Bottom", "Left"]["each"](function(direction) {
    for (var style in aspss["Element"]["Styles"]) {
        aspss["Element"]["Styles"][style]["push"](style + direction);
    };
});
aspss["Element"]["getMany"] = function(el, method, keys) {
    var result = {};
    aspss.$each(keys,
    function(key) {
        result[key] = el[method](key);
    });
    return result;
};
aspss["Element"]["setMany"] = function(el, method, pairs) {
    for (var key in pairs) {
        el[method](key, pairs[key]);
    };
    return el;
};
aspss["Element"]["Properties"] = new aspss.Abstract({
    "class": "className",
    "for": "htmlFor",
    "colspan": "colSpan",
    "rowspan": "rowSpan",
    "accesskey": "accessKey",
    "tabindex": "tabIndex",
    "maxlength": "maxLength",
    "readonly": "readOnly",
    "value": "value",
    "disabled": "disabled",
    "checked": "checked",
    "multiple": "multiple"
});
aspss["Element"]["listenerMethods"] = {
    addListener: function(type, fn) {
        if (this["addEventListener"]) {
            this["addEventListener"](type, fn, false);
        } else {
            this["attachEvent"]("on" + type, fn);
        };
        return this;
    },
    removeListener: function(type, fn) {
        if (this["removeEventListener"]) {
            this["removeEventListener"](type, fn, false);
        } else {
            this["detachEvent"]("on" + type, fn);
        };
        return this;
    }
};
window["extend"](aspss["Element"]["listenerMethods"]);
document["extend"](aspss["Element"]["listenerMethods"]);
aspss["Element"]["extend"](aspss["Element"]["listenerMethods"]);
aspss["Element"]["Events"] = new aspss.Abstract({});
aspss["Garbage"] = {
    elements: [],
    collect: function(el) {
        if (!el["$"]) {
            aspss["Garbage"]["elements"]["push"](el);
            el["$"] = {
                "opacity": 1
            };
        };
        return el;
    },
    trash: function(elements) {
        for (var i = 0, j = elements["length"], el; i < j; i++) {
            if (! (el = elements[i]) || !el["$"]) {
                return;
            };
            if (el["$events"]) {
                el["fireEvent"]("onTrash");
                el["removeEvents"]();
            };
            for (var p in el["$"]) {
                el["$"][p] = null;
            };
            for (var p in aspss["Element"]["prototype"]) {
                el[p] = null;
            };
            el["htmlElement"] = el["$"] = null;
            aspss["Garbage"]["elements"]["remove"](el);
        };
    },
    empty: function() {
        aspss["Garbage"]["collect"](window);
        aspss["Garbage"]["collect"](document);
        aspss["Garbage"]["trash"](aspss["Garbage"]["elements"]);
    }
};
window["addListener"]("unload", aspss["Garbage"]["empty"]);
aspss["Event"] = new aspss.Class({
    initialize: function(event) {
        event = event || window["event"];
        this["event"] = event;
        this["type"] = event["type"];
        this["target"] = event["target"] || event["srcElement"];
        if (this["target"]["nodeType"] == 3) {
            this["target"] = this["target"]["parentNode"];
        };
        this["shift"] = event["shiftKey"];
        this["control"] = event["ctrlKey"];
        this["alt"] = event["altKey"];
        this["meta"] = event["metaKey"];
        if (["DOMMouseScroll", "mousewheel"]["contains"](this["type"])) {
            this["wheel"] = (event["wheelDelta"]) ? event["wheelDelta"] / 120 : -(event["detail"] || 0) / 3;
        } else {
            if (this["type"]["contains"]("key")) {
                this["code"] = event["which"] || event["keyCode"];
                for (var name in aspss["Event"]["keys"]) {
                    if (aspss["Event"]["keys"][name] == this["code"]) {
                        this["key"] = name;
                        break;
                    };
                };
                if (this["type"] == "keydown") {
                    var fKey = this["code"] - 111;
                    if (fKey > 0 && fKey < 13) {
                        this["key"] = "f" + fKey;
                    };
                };
                this["key"] = this["key"] || String["fromCharCode"](this["code"])["toLowerCase"]();
            } else {
                if (this["type"]["test"](/(click|mouse|menu)/)) {
                    this["page"] = {
                        "x": event["pageX"] || event["clientX"] + document["documentElement"]["scrollLeft"],
                        "y": event["pageY"] || event["clientY"] + document["documentElement"]["scrollTop"]
                    };
                    this["client"] = {
                        "x": event["pageX"] ? event["pageX"] - window["pageXOffset"] : event["clientX"],
                        "y": event["pageY"] ? event["pageY"] - window["pageYOffset"] : event["clientY"]
                    };
                    this["rightClick"] = (event["which"] == 3) || (event["button"] == 2);
                    switch (this["type"]) {
                    case "mouseover":
                        this["relatedTarget"] = event["relatedTarget"] || event["fromElement"];
                        break;;
                    case "mouseout":
                        this["relatedTarget"] = event["relatedTarget"] || event["toElement"];;
                    };
                    if (this["relatedTarget"] && this["relatedTarget"]["nodeType"] == 3) {
                        this["relatedTarget"] = this["relatedTarget"]["parentNode"];
                    };
                };
            };
        };
    },
    stop: function() {
        return this["stopPropagation"]()["preventDefault"]();
    },
    stopPropagation: function() {
        if (this["event"]["stopPropagation"]) {
            this["event"]["stopPropagation"]();
        } else {
            this["event"]["cancelBubble"] = true;
        };
        return this;
    },
    preventDefault: function() {
        if (this["event"]["preventDefault"]) {
            this["event"]["preventDefault"]();
        } else {
            this["event"]["returnValue"] = false;
        };
        return this;
    }
});
aspss["Event"]["keys"] = new aspss.Abstract({
    "enter": 13,
    "up": 38,
    "down": 40,
    "left": 37,
    "right": 39,
    "esc": 27,
    "space": 32,
    "backspace": 8,
    "tab": 9,
    "delete": 46
});
aspss["Element"]["Events"]["extend"]({
    "mouseenter": {
        type: "mouseover",
        map: function(event) {
            event = new aspss.Event(event);
            if (event["relatedTarget"] == this || this["hasChild"](event["relatedTarget"])) {
                return;
            };
            this["fireEvent"]("mouseenter", event);
        }
    },
    "mouseleave": {
        type: "mouseout",
        map: function(event) {
            event = new aspss.Event(event);
            if (event["relatedTarget"] == this || this["hasChild"](event["relatedTarget"])) {
                return;
            };
            this["fireEvent"]("mouseleave", event);
        }
    }
});
Function["extend"]({
    bindWithEvent: function(bind, args) {
        return this["create"]({
            "bind": bind,
            "arguments": args,
            "event": aspss["Event"]
        });
    }
});
aspss["$E"] = function(selector, filter) {
    return (aspss.$(filter) || document)["getElement"](selector);
};
aspss["$ES"] = function(selector, filter) {
    return (aspss.$(filter) || document)["getElementsBySelector"](selector);
};
aspss["$$"]["shared"] = {
    cache: {},
    regexp: /^(\w*|\*)(?:#([\w-]+)|\.([\w-]+))?(?:\[(\w+)(?:([!*^$]?=)["']?([^"'\]]*)["']?)?])?$/,
    getNormalParam: function(selector, items, context, param, i) {
        aspss["Filters"]["selector"] = param;
        if (i == 0) {
            if (param[2]) {
                var el = context["getElementById"](param[2]);
                if (!el || ((param[1] != "*") && (el["tagName"]["toLowerCase"]() != param[1]))) {
                    return false;
                };
                items = [el];
            } else {
                items = aspss.$A(context["getElementsByTagName"](param[1]));
            };
        } else {
            items = aspss["$$"]["shared"]["getElementsByTagName"](items, param[1]);
            if (param[2]) {
                items = items["filter"](aspss["Filters"]["id"]);
            };
        };
        if (param[3]) {
            items = items["filter"](aspss["Filters"]["className"]);
        };
        if (param[4]) {
            items = items["filter"](aspss["Filters"]["attribute"]);
        };
        return items;
    },
    getXpathParam: function(selector, items, context, param, i) {
        if (aspss["$$"]["shared"]["cache"][selector]["xpath"]) {
            items["push"](aspss["$$"]["shared"]["cache"][selector]["xpath"]);
            return items;
        };
        var temp = context["namespaceURI"] ? ["xhtml:"] : [];
        temp["push"](param[1]);
        if (param[2]) {
            temp["push"]("[@id=\x22", param[2], "\x22]");
        };
        if (param[3]) {
            temp["push"]("[contains(concat(\x22 \x22, @class, \x22 \x22), \x22 ", param[3], " \x22)]");
        };
        if (param[4]) {
            if (param[5] && param[6]) {
                switch (param[5]) {
                case "*=":
                    temp["push"]("[contains(@", param[4], ", \x22", param[6], "\x22)]");
                    break;;
                case "^=":
                    temp["push"]("[starts-with(@", param[4], ", \x22", param[6], "\x22)]");
                    break;;
                case "aspss.$=":
                    temp["push"]("[substring(@", param[4], ", string-length(@", param[4], ") - ", param[6]["length"], " + 1) = \x22", param[6], "\x22]");
                    break;;
                case "=":
                    temp["push"]("[@", param[4], "=\x22", param[6], "\x22]");
                    break;;
                case "!=":
                    temp["push"]("[@", param[4], "!=\x22", param[6], "\x22]");;
                };
            } else {
                temp["push"]("[@", param[4], "]");
            };
        };
        temp = temp["join"]("");
        aspss["$$"]["shared"]["cache"][selector]["xpath"] = temp;
        items["push"](temp);
        return items;
    },
    getNormalItems: function(items, context, nocash) {
        return (nocash) ? items: aspss["$$"]["unique"](items);
    },
    getXpathItems: function(items, context, nocash) {
        var elements = [];
        var xpath = document["evaluate"](".//" + items["join"]("//"), context, aspss["$$"]["shared"]["resolver"], XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null);
        for (var i = 0, j = xpath["snapshotLength"]; i < j; i++) {
            elements["push"](xpath["snapshotItem"](i));
        };
        return (nocash) ? elements: aspss.$extend(elements["map"](aspss.$), new aspss.Elements);
    },
    resolver: function(prefix) {
        return (prefix == "xhtml") ? "http://www.w3.org/1999/xhtml": false;
    },
    getElementsByTagName: function(context, tagName) {
        var found = [];
        for (var i = 0, j = context["length"]; i < j; i++) {
            found = found["concat"](aspss.$A(context[i]["getElementsByTagName"](tagName)));
        };
        return found;
    }
};
if (window["xpath"]) {
    aspss["$$"]["shared"]["getParam"] = aspss["$$"]["shared"]["getXpathParam"];
    aspss["$$"]["shared"]["getItems"] = aspss["$$"]["shared"]["getXpathItems"];
} else {
    aspss["$$"]["shared"]["getParam"] = aspss["$$"]["shared"]["getNormalParam"];
    aspss["$$"]["shared"]["getItems"] = aspss["$$"]["shared"]["getNormalItems"];
};
aspss["Element"]["domMethods"] = {
    getElements: function(selector, nocash) {
        var items = [];
        selector = selector["trim"]()["split"](" ");
        for (var i = 0, j = selector["length"]; i < j; i++) {
            var sel = selector[i];
            var param;
            if (aspss["$$"]["shared"]["cache"][sel]) {
                param = aspss["$$"]["shared"]["cache"][sel]["param"];
            } else {
                param = sel["match"](aspss["$$"]["shared"]["regexp"]);
                if (!param) {
                    break;
                };
                param[1] = param[1] || "*";
                aspss["$$"]["shared"]["cache"][sel] = {
                    "param": param
                };
            };
            var temp = aspss["$$"]["shared"]["getParam"](sel, items, this, param, i);
            if (!temp) {
                break;
            };
            items = temp;
        };
        return aspss["$$"]["shared"]["getItems"](items, this, nocash);
    },
    getElement: function(selector) {
        return aspss.$(this["getElements"](selector, true)[0] || false);
    },
    getElementsBySelector: function(selector, nocash) {
        var elements = [];
        selector = selector["split"](",");
        for (var i = 0, j = selector["length"]; i < j; i++) {
            elements = elements["concat"](this["getElements"](selector[i], true));
        };
        return (nocash) ? elements: aspss["$$"]["unique"](elements);
    },
    getElementsByClassName: function(className) {
        return this["getElements"]("." + className);
    }
};
aspss["Element"]["extend"]({
    getElementById: function(id) {
        var el = document["getElementById"](id);
        if (!el) {
            return false;
        };
        for (var parent = el["parentNode"]; parent != this; parent = parent["parentNode"]) {
            if (!parent) {
                return false;
            };
        };
        return el;
    }
});
document["extend"](aspss["Element"]["domMethods"]);
aspss["Element"]["extend"](aspss["Element"]["domMethods"]);
aspss["Filters"] = {
    selector: [],
    id: function(el) {
        return (el["id"] == aspss["Filters"]["selector"][2]);
    },
    className: function(el) {
        return el["className"]["contains"](aspss["Filters"]["selector"][3], " ");
    },
    attribute: function(el) {
        var current = aspss["Element"]["prototype"]["getProperty"]["call"](el, aspss["Filters"]["selector"][4]);
        if (!current) {
            return false;
        };
        var operator = aspss["Filters"]["selector"][5];
        if (!operator) {
            return true;
        };
        var value = aspss["Filters"]["selector"][6];
        switch (operator) {
        case "=":
            return (current == value);;
        case "*=":
            return (current["contains"](value));;
        case "^=":
            return (current["test"]("^" + value));;
        case "aspss.$=":
            return (current["test"](value + "aspss.$"));;
        case "!=":
            return (current != value);;
        case "~=":
            return current["contains"](value, " ");;
        };
        return false;
    }
};
aspss["Element"]["extend"]({
    getValue: function() {
        switch (this["getTag"]()) {
        case "select":
            var values = [];
            aspss.$each(this["options"],
            function(opt) {
                if (opt["selected"]) {
                    values["push"](aspss.$pick(opt["value"], opt["text"]));
                };
            });
            return (this["multiple"]) ? values: values[0];;
        case "input":
            if (! (this["checked"] && ["checkbox", "radio"]["contains"](this["type"])) && !["hidden", "text", "password"]["contains"](this["type"])) {
                break;
            };;
        case "textarea":
            return this["value"];;
        };
        return false;
    },
    getFormElements: function() {
        return aspss.$$(this["getElementsByTagName"]("input"), this["getElementsByTagName"]("select"), this["getElementsByTagName"]("textarea"));
    },
    toQueryString: function() {
        var queryString = [];
        this["getFormElements"]()["each"](function(el) {
            var name = el["name"];
            var value = el["getValue"]();
            if (value === false || !name || el["disabled"]) {
                return;
            };
            var qs = function(val) {
                queryString["push"](name + "=" + encodeURIComponent(val));
            };
            if (aspss.$type(value) == "array") {
                value["each"](qs);
            } else {
                qs(value);
            };
        });
        return queryString["join"]("\x26");
    }
});
aspss["Element"]["extend"]({
    scrollTo: function(x, y) {
        this["scrollLeft"] = x;
        this["scrollTop"] = y;
    },
    getSize: function() {
        return {
            "scroll": {
                "x": this["scrollLeft"],
                "y": this["scrollTop"]
            },
            "size": {
                "x": this["offsetWidth"],
                "y": this["offsetHeight"]
            },
            "scrollSize": {
                "x": this["scrollWidth"],
                "y": this["scrollHeight"]
            }
        };
    },
    getPosition: function(overflown) {
        overflown = overflown || [];
        var el = this,
        left = 0,
        top = 0;
        do {
            left += el["offsetLeft"] || 0;
            top += el["offsetTop"] || 0;
            el = el["offsetParent"];
        } while (el);;
        overflown["each"](function(element) {
            left -= element["scrollLeft"] || 0;
            top -= element["scrollTop"] || 0;
        });
        return {
            "x": left,
            "y": top
        };
    },
    getTop: function() {
        return this["getPosition"]()["y"];
    },
    getLeft: function() {
        return this["getPosition"]()["x"];
    },
    getCoordinates: function(overflown) {
        var position = this["getPosition"](overflown);
        var obj = {
            "width": this["offsetWidth"],
            "height": this["offsetHeight"],
            "left": position["x"],
            "top": position["y"]
        };
        obj["right"] = obj["left"] + obj["width"];
        obj["bottom"] = obj["top"] + obj["height"];
        return obj;
    }
});
aspss["Element"]["eventMethods"] = {
    addEvent: function(type, fn) {
        this["$events"] = this["$events"] || {};
        this["$events"][type] = this["$events"][type] || {
            "keys": [],
            "values": []
        };
        if (this["$events"][type]["keys"]["contains"](fn)) {
            return this;
        };
        this["$events"][type]["keys"]["push"](fn);
        var realType = type;
        var bound = false;
        if (aspss["Element"]["Events"][type]) {
            if (aspss["Element"]["Events"][type]["add"]) {
                aspss["Element"]["Events"][type]["add"]["call"](this, fn);
            };
            if (aspss["Element"]["Events"][type]["map"]) {
                bound = aspss["Element"]["Events"][type]["map"]["bindAsEventListener"](this);
            };
            realType = aspss["Element"]["Events"][type]["type"] || type;
        };
        if (!this["addEventListener"]) {
            bound = bound || fn["bindAsEventListener"](this);
        } else {
            bound = bound || fn;
        };
        this["$events"][type]["values"]["push"](bound);
        return this["addListener"](realType, bound);
    },
    removeEvent: function(type, fn) {
        if (!this["$events"] || !this["$events"][type]) {
            return this;
        };
        var pos = this["$events"][type]["keys"]["indexOf"](fn);
        if (pos == -1) {
            return this;
        };
        var key = this["$events"][type]["keys"]["splice"](pos, 1)[0];
        var value = this["$events"][type]["values"]["splice"](pos, 1)[0];
        if (aspss["Element"]["Events"][type]) {
            if (aspss["Element"]["Events"][type]["remove"]) {
                aspss["Element"]["Events"][type]["remove"]["call"](this, fn);
            };
            type = aspss["Element"]["Events"][type]["type"] || type;
        };
        return this["removeListener"](type, value);
    },
    addEvents: function(source) {
        return aspss["Element"]["setMany"](this, "addEvent", source);
    },
    removeEvents: function(type) {
        if (!this["$events"]) {
            return this;
        };
        if (type) {
            if (this["$events"][type]) {
                aspss.$A(this["$events"][type]["keys"])["each"](function(fn, i) {
                    this["removeEvent"](type, fn);
                },
                this);
                this["$events"][type] = null;
            };
        } else {
            for (var evType in this["$events"]) {
                this["removeEvents"](evType);
            };
            this["$events"] = null;
        };
        return this;
    },
    fireEvent: function(type, args) {
        if (this["$events"] && this["$events"][type]) {
            this["$events"][type]["keys"]["each"](function(fn) {
                fn["bind"](this, args)();
            },
            this);
        };
    }
};
aspss["Element"]["Events"]["mousewheel"] = {
    type: (window["gecko"]) ? "DOMMouseScroll": "mousewheel"
};
window["extend"](aspss["Element"]["eventMethods"]);
document["extend"](aspss["Element"]["eventMethods"]);
aspss["Element"]["extend"](aspss["Element"]["eventMethods"]);
aspss["Element"]["Events"]["domready"] = {
    add: function(fn) {
        if (window["loaded"]) {
            fn["call"](this);
            return;
        };
        var domReady = function() {
            if (window["loaded"]) {
                return;
            };
            window["loaded"] = true;
            window["timer"] = aspss.$clear(window["timer"]);
            this["fireEvent"]("domready");
        } ["bind"](this);
        if (document["readyState"] && window["khtml"]) {
            window["timer"] = function() {
                if (["loaded", "complete"]["contains"](document["readyState"])) {
                    domReady();
                };
            } ["periodical"](50);
        } else {
            if (document["readyState"] && window["ie"]) {
                if (!aspss.$("ie_ready")) {
                    var src = (window["location"]["protocol"] == "https:") ? "://0": "javascript:void(0)";
                    document["write"]("\x3Cscript id=\x22ie_ready\x22 defer src=\x22" + src + "\x22\x3E\x3C/script\x3E");
                    aspss.$("ie_ready")["onreadystatechange"] = function() {
                        if (this["readyState"] == "complete") {
                            domReady();
                        };
                    };
                };
            } else {
                window["addListener"]("load", domReady);
                document["addListener"]("DOMContentLoaded", domReady);
            };
        };
    }
};
window["onDomReady"] = function(fn) {
    return this["addEvent"]("domready", fn);
};
window["extend"]({
    getWidth: function() {
        if (this["khtml"]) {
            return this["innerWidth"];
        };
        if (this["opera"]) {
            return document["body"]["clientWidth"];
        };
        return document["documentElement"]["clientWidth"];
    },
    getHeight: function() {
        if (this["khtml"]) {
            return this["innerHeight"];
        };
        if (this["opera"]) {
            return document["body"]["clientHeight"];
        };
        return document["documentElement"]["clientHeight"];
    },
    getScrollWidth: function() {
        if (this["ie"]) {
            return Math["max"](document["documentElement"]["offsetWidth"], document["documentElement"]["scrollWidth"]);
        };
        if (this["khtml"]) {
            return document["body"]["scrollWidth"];
        };
        return document["documentElement"]["scrollWidth"];
    },
    getScrollHeight: function() {
        if (this["ie"]) {
            return Math["max"](document["documentElement"]["offsetHeight"], document["documentElement"]["scrollHeight"]);
        };
        if (this["khtml"]) {
            return document["body"]["scrollHeight"];
        };
        return document["documentElement"]["scrollHeight"];
    },
    getScrollLeft: function() {
        return this["pageXOffset"] || document["documentElement"]["scrollLeft"];
    },
    getScrollTop: function() {
        return this["pageYOffset"] || document["documentElement"]["scrollTop"];
    },
    getSize: function() {
        return {
            "size": {
                "x": this["getWidth"](),
                "y": this["getHeight"]()
            },
            "scrollSize": {
                "x": this["getScrollWidth"](),
                "y": this["getScrollHeight"]()
            },
            "scroll": {
                "x": this["getScrollLeft"](),
                "y": this["getScrollTop"]()
            }
        };
    },
    getPosition: function() {
        return {
            "x": 0,
            "y": 0
        };
    }
});
aspss["Fx"] = {
    Shared: {}
};
aspss["Fx"]["Base"] = new aspss.Class({
    options: {
        onStart: aspss["Class"]["empty"],
        onComplete: aspss["Class"]["empty"],
        onCancel: aspss["Class"]["empty"],
        transition: function(t, c, d) {
            return - c / 2 * (Math["cos"](Math["PI"] * t / d) - 1);
        },
        duration: 500,
        unit: "px",
        wait: true,
        fps: 50
    },
    initialize: function(options) {
        this["element"] = this["element"] || null;
        this["setOptions"](options);
        if (this["options"]["initialize"]) {
            this["options"]["initialize"]["call"](this);
        };
    },
    step: function() {
        var time = aspss.$time();
        if (time < this["time"] + this["options"]["duration"]) {
            this["cTime"] = time - this["time"];
            this["setNow"]();
            this["increase"]();
        } else {
            this["stop"](true);
            this["now"] = this["to"];
            this["increase"]();
            this["fireEvent"]("onComplete", this["element"], 10);
            this["callChain"]();
        };
    },
    set: function(to) {
        this["now"] = to;
        this["increase"]();
        return this;
    },
    setNow: function() {
        this["now"] = this["compute"](this["from"], this["to"]);
    },
    compute: function(from, to) {
        return this["options"]["transition"](this["cTime"], (to - from), this["options"]["duration"]) + from;
    },
    start: function(from, to) {
        if (!this["options"]["wait"]) {
            this["stop"]();
        } else {
            if (this["timer"]) {
                return this;
            };
        };
        this["from"] = from;
        this["to"] = to;
        this["time"] = aspss.$time();
        if (!this["options"]["fps"]) {
            this["options"]["fps"] = 30;
        };
        this["timer"] = this["step"]["periodical"](Math["round"](1000 / this["options"]["fps"]), this);
        this["fireEvent"]("onStart", this["element"]);
        return this;
    },
    stop: function(end) {
        if (!this["timer"]) {
            return this;
        };
        this["timer"] = aspss.$clear(this["timer"]);
        if (!end) {
            this["fireEvent"]("onCancel", this["element"]);
        };
        return this;
    },
    custom: function(from, to) {
        return this["start"](from, to);
    },
    clearTimer: function(end) {
        return this["stop"](end);
    }
});
aspss["Fx"]["Base"]["implement"](new aspss.Chain);
aspss["Fx"]["Base"]["implement"](new aspss.Events);
aspss["Fx"]["Base"]["implement"](new aspss.Options);
aspss["Fx"]["CSS"] = {
    select: function(property, to) {
        if (property["test"](/color/i)) {
            return this["Color"];
        };
        if (to["contains"] && to["contains"](" ")) {
            return this["Multi"];
        };
        return this["Single"];
    },
    parse: function(el, property, fromTo) {
        if (!fromTo["push"]) {
            fromTo = [fromTo];
        };
        var from = fromTo[0],
        to = fromTo[1];
        if (!to && to != 0) {
            to = from;
            from = el["getStyle"](property);
        };
        var css = this["select"](property, to);
        return {
            from: css["parse"](from),
            to: css["parse"](to),
            css: css
        };
    }
};
aspss["Fx"]["CSS"]["Single"] = {
    parse: function(value) {
        return parseFloat(value);
    },
    getNow: function(from, to, fx) {
        return fx["compute"](from, to);
    },
    getValue: function(value, unit) {
        return value + unit;
    }
};
aspss["Fx"]["CSS"]["Multi"] = {
    parse: function(value) {
        return value["push"] ? value: value["split"](" ")["map"](function(v) {
            return parseFloat(v);
        });
    },
    getNow: function(from, to, fx) {
        var now = [];
        for (var i = 0; i < from["length"]; i++) {
            now[i] = fx["compute"](from[i], to[i]);
        };
        return now;
    },
    getValue: function(value, unit) {
        return value["join"](unit + " ") + unit;
    }
};
aspss["Fx"]["CSS"]["Color"] = {
    parse: function(value) {
        return value["push"] ? value: value["hexToRgb"](true);
    },
    getNow: function(from, to, fx) {
        var now = [];
        for (var i = 0; i < from["length"]; i++) {
            now[i] = Math["round"](fx["compute"](from[i], to[i]));
        };
        return now;
    },
    getValue: function(value) {
        return "rgb(" + value["join"](",") + ")";
    }
};
aspss["Fx"]["Style"] = aspss["Fx"]["Base"]["extend"]({
    initialize: function(el, property, options) {
        this["element"] = aspss.$(el);
        this["property"] = property;
        this["parent"](options);
    },
    hide: function() {
        return this["set"](0);
    },
    setNow: function() {
        this["now"] = this["css"]["getNow"](this["from"], this["to"], this);
    },
    set: function(to) {
        this["css"] = aspss["Fx"]["CSS"]["select"](this["property"], to);
        return this["parent"](this["css"]["parse"](to));
    },
    start: function(from, to) {
        if (this["timer"] && this["options"]["wait"]) {
            return this;
        };
        var parsed = aspss["Fx"]["CSS"]["parse"](this["element"], this["property"], [from, to]);
        this["css"] = parsed["css"];
        return this["parent"](parsed["from"], parsed["to"]);
    },
    increase: function() {
        this["element"]["setStyle"](this["property"], this["css"]["getValue"](this["now"], this["options"]["unit"]));
    }
});
aspss["Element"]["extend"]({
    effect: function(property, options) {
        return new aspss["Fx"].Style(this, property, options);
    }
});
aspss["Fx"]["Styles"] = aspss["Fx"]["Base"]["extend"]({
    initialize: function(el, options) {
        this["element"] = aspss.$(el);
        this["parent"](options);
    },
    setNow: function() {
        for (var p in this["from"]) {
            this["now"][p] = this["css"][p]["getNow"](this["from"][p], this["to"][p], this);
        };
    },
    set: function(to) {
        var parsed = {};
        this["css"] = {};
        for (var p in to) {
            this["css"][p] = aspss["Fx"]["CSS"]["select"](p, to[p]);
            parsed[p] = this["css"][p]["parse"](to[p]);
        };
        return this["parent"](parsed);
    },
    start: function(obj) {
        if (this["timer"] && this["options"]["wait"]) {
            return this;
        };
        this["now"] = {};
        this["css"] = {};
        var from = {},
        to = {};
        for (var p in obj) {
            var parsed = aspss["Fx"]["CSS"]["parse"](this["element"], p, obj[p]);
            from[p] = parsed["from"];
            to[p] = parsed["to"];
            this["css"][p] = parsed["css"];
        };
        return this["parent"](from, to);
    },
    increase: function() {
        for (var p in this["now"]) {
            this["element"]["setStyle"](p, this["css"][p]["getValue"](this["now"][p], this["options"]["unit"]));
        };
    }
});
aspss["Element"]["extend"]({
    effects: function(options) {
        return new aspss["Fx"].Styles(this, options);
    }
});
aspss["Fx"]["Elements"] = aspss["Fx"]["Base"]["extend"]({
    initialize: function(elements, options) {
        this["elements"] = aspss.$$(elements);
        this["parent"](options);
    },
    setNow: function() {
        for (var i in this["from"]) {
            var iFrom = this["from"][i],
            iTo = this["to"][i],
            iCss = this["css"][i],
            iNow = this["now"][i] = {};
            for (var p in iFrom) {
                iNow[p] = iCss[p]["getNow"](iFrom[p], iTo[p], this);
            };
        };
    },
    set: function(to) {
        var parsed = {};
        this["css"] = {};
        for (var i in to) {
            var iTo = to[i],
            iCss = this["css"][i] = {},
            iParsed = parsed[i] = {};
            for (var p in iTo) {
                iCss[p] = aspss["Fx"]["CSS"]["select"](p, iTo[p]);
                iParsed[p] = iCss[p]["parse"](iTo[p]);
            };
        };
        return this["parent"](parsed);
    },
    start: function(obj) {
        if (this["timer"] && this["options"]["wait"]) {
            return this;
        };
        this["now"] = {};
        this["css"] = {};
        var from = {},
        to = {};
        for (var i in obj) {
            var iProps = obj[i],
            iFrom = from[i] = {},
            iTo = to[i] = {},
            iCss = this["css"][i] = {};
            for (var p in iProps) {
                var parsed = aspss["Fx"]["CSS"]["parse"](this["elements"][i], p, iProps[p]);
                iFrom[p] = parsed["from"];
                iTo[p] = parsed["to"];
                iCss[p] = parsed["css"];
            };
        };
        return this["parent"](from, to);
    },
    increase: function() {
        for (var i in this["now"]) {
            var iNow = this["now"][i],
            iCss = this["css"][i];
            for (var p in iNow) {
                this["elements"][i]["setStyle"](p, iCss[p]["getValue"](iNow[p], this["options"]["unit"]));
            };
        };
    }
});
aspss["Fx"]["Scroll"] = aspss["Fx"]["Base"]["extend"]({
    initialize: function(element, options) {
        this["now"] = [];
        this["element"] = aspss.$(element);
        this["addEvent"]("onStart",
        function() {
            this["element"]["addEvent"]("mousewheel", this["stop"]["bind"](this, false));
        } ["bind"](this));
        this["removeEvent"]("onComplete",
        function() {
            this["element"]["removeEvent"]("mousewheel", this["stop"]["bind"](this, false));
        } ["bind"](this));
        this["parent"](options);
    },
    setNow: function() {
        for (var i = 0; i < 2; i++) {
            this["now"][i] = this["compute"](this["from"][i], this["to"][i]);
        };
    },
    scrollTo: function(x, y) {
        if (this["timer"] && this["options"]["wait"]) {
            return this;
        };
        var el = this["element"]["getSize"]();
        var values = {
            "x": x,
            "y": y
        };
        for (var z in el["size"]) {
            var max = el["scrollSize"][z] - el["size"][z];
            if (aspss.$chk(values[z])) {
                values[z] = (aspss.$type(values[z]) == "number") ? Math["max"](Math["min"](values[z], max), 0) : max;
            } else {
                values[z] = el["scroll"][z];
            };
        };
        return this["start"]([el["scroll"]["x"], el["scroll"]["y"]], [values["x"], values["y"]]);
    },
    toTop: function() {
        return this["scrollTo"](false, 0);
    },
    toBottom: function() {
        return this["scrollTo"](false, "full");
    },
    toLeft: function() {
        return this["scrollTo"](0, false);
    },
    toRight: function() {
        return this["scrollTo"]("full", false);
    },
    toElement: function(el) {
        var parent = this["element"]["getPosition"]();
        var target = aspss.$(el)["getPosition"]();
        return this["scrollTo"](target["x"] - parent["x"], target["y"] - parent["y"]);
    },
    increase: function() {
        this["element"]["scrollTo"](this["now"][0], this["now"][1]);
    }
});
aspss["Fx"]["Slide"] = aspss["Fx"]["Base"]["extend"]({
    options: {
        mode: "vertical"
    },
    initialize: function(el, options) {
        this["element"] = aspss.$(el);
        this["wrapper"] = new aspss.Element("div", {
            "styles": aspss.$extend(this["element"]["getStyles"]("margin"), {
                "overflow": "hidden"
            })
        })["injectAfter"](this["element"])["adopt"](this["element"]);
        this["element"]["setStyle"]("margin", 0);
        this["setOptions"](options);
        this["now"] = [];
        this["parent"](this["options"]);
    },
    setNow: function() {
        for (var i = 0; i < 2; i++) {
            this["now"][i] = this["compute"](this["from"][i], this["to"][i]);
        };
    },
    vertical: function() {
        this["margin"] = "margin-top";
        this["layout"] = "height";
        this["offset"] = this["element"]["offsetHeight"];
    },
    horizontal: function() {
        this["margin"] = "margin-left";
        this["layout"] = "width";
        this["offset"] = this["element"]["offsetWidth"];
    },
    slideIn: function(mode) {
        this[mode || this["options"]["mode"]]();
        return this["start"]([this["element"]["getStyle"](this["margin"])["toInt"](), this["wrapper"]["getStyle"](this["layout"])["toInt"]()], [0, this["offset"]]);
    },
    slideOut: function(mode) {
        this[mode || this["options"]["mode"]]();
        return this["start"]([this["element"]["getStyle"](this["margin"])["toInt"](), this["wrapper"]["getStyle"](this["layout"])["toInt"]()], [ - this["offset"], 0]);
    },
    hide: function(mode) {
        this[mode || this["options"]["mode"]]();
        return this["set"]([ - this["offset"], 0]);
    },
    show: function(mode) {
        this[mode || this["options"]["mode"]]();
        return this["set"]([0, this["offset"]]);
    },
    toggle: function(mode) {
        if (this["wrapper"]["offsetHeight"] == 0 || this["wrapper"]["offsetWidth"] == 0) {
            return this["slideIn"](mode);
        };
        return this["slideOut"](mode);
    },
    increase: function() {
        this["element"]["setStyle"](this["margin"], this["now"][0] + this["options"]["unit"]);
        this["wrapper"]["setStyle"](this["layout"], this["now"][1] + this["options"]["unit"]);
    }
});
aspss["Fx"]["Transitions"] = new aspss.Abstract({
    linear: function(t, c, d) {
        return c * (t / d);
    }
});
aspss["Fx"]["Shared"]["CreateTransitionEases"] = function(transition, type) {
    aspss.$extend(transition, {
        easeIn: function(t, c, d, x, y, z) {
            return c - c * transition((d - t) / d, t, c, d, x, y, z);
        },
        easeOut: function(t, c, d, x, y, z) {
            return c * transition(t / d, t, c, d, x, y, z);
        },
        easeInOut: function(t, c, d, x, y, z) {
            d /= 2;
            c /= 2;
            var p = t / d;
            return (p < 1) ? transition["easeIn"](t, c, d, x, y, z) : c * (transition(p - 1, t, c, d, x, y, z) + 1);
        }
    });
    ["In", "Out", "InOut"]["each"](function(mode) {
        transition["ease" + mode]["set"] = aspss["Fx"]["Shared"].SetTransitionValues(transition["ease" + mode]);
        aspss["Fx"]["Transitions"][type["toLowerCase"]() + mode] = transition["ease" + mode];
    });
};
aspss["Fx"]["Shared"]["SetTransitionValues"] = function(transition) {
    return function() {
        var args = aspss.$A(arguments);
        return function() {
            return transition["apply"](aspss["Fx"].Transitions, aspss.$A(arguments)["concat"](args));
        };
    };
};
aspss["Fx"]["Transitions"]["extend"] = function(transitions) {
    for (var type in transitions) {
        if (type["test"](/^[A-Z]/)) {
            aspss["Fx"]["Shared"].CreateTransitionEases(transitions[type], type);
        } else {
            transitions[type]["set"] = aspss["Fx"]["Shared"].SetTransitionValues(transitions[type]);
        };
        aspss["Fx"]["Transitions"][type] = transitions[type];
    };
};
aspss["Fx"]["Transitions"]["extend"]({
    Sine: function(p) {
        return Math["sin"](p * (Math["PI"] / 2));
    },
    Quad: function(p) {
        return - (Math["pow"](p - 1, 2) - 1);
    },
    Cubic: function(p) {
        return Math["pow"](p - 1, 3) + 1;
    },
    Quart: function(p) {
        return - (Math["pow"](p - 1, 4) - 1);
    },
    Quint: function(p) {
        return Math["pow"](p - 1, 5) + 1;
    },
    Expo: function(p) {
        return - Math["pow"](2, -10 * p) + 1;
    },
    Circ: function(p) {
        return Math["sqrt"](1 - Math["pow"](p - 1, 2));
    },
    Bounce: function(p) {
        var b = 7.5625;
        if (p < (1 / 2.75)) {
            return b * Math["pow"](p, 2);
        } else {
            if (p < (2 / 2.75)) {
                return b * (p -= (1.5 / 2.75)) * p + 0.75;
            } else {
                if (p < (2.5 / 2.75)) {
                    return b * (p -= (2.25 / 2.75)) * p + 0.9375;
                } else {
                    return b * (p -= (2.625 / 2.75)) * p + 0.984375;
                };
            };
        };
    },
    Back: function(p, t, c, d, x) {
        x = x || 1.70158;
        p -= 1;
        return Math["pow"](p, 2) * ((x + 1) * p + x) + 1;
    },
    Elastic: function(p, t, c, d, x) {
        x = d * 0.3 / (x || 1);
        return (c * Math["pow"](2, -10 * p) * Math["sin"]((p * d - x / 4) * (2 * Math["PI"]) / x) + c) / c;
    }
});
aspss["Drag"] = {};
aspss["Drag"]["Base"] = new aspss.Class({
    options: {
        handle: false,
        unit: "px",
        onStart: aspss["Class"]["empty"],
        onBeforeStart: aspss["Class"]["empty"],
        onComplete: aspss["Class"]["empty"],
        onSnap: aspss["Class"]["empty"],
        onDrag: aspss["Class"]["empty"],
        limit: false,
        modifiers: {
            x: "left",
            y: "top"
        },
        grid: false,
        snap: 6
    },
    initialize: function(el, options) {
        this["setOptions"](options);
        this["element"] = aspss.$(el);
        this["handle"] = aspss.$(this["options"]["handle"]) || this["element"];
        this["mouse"] = {
            "now": {},
            "pos": {}
        };
        this["value"] = {
            "start": {},
            "now": {}
        };
        this["bound"] = {
            "start": this["start"]["bindWithEvent"](this),
            "check": this["check"]["bindWithEvent"](this),
            "drag": this["drag"]["bindWithEvent"](this),
            "stop": this["stop"]["bind"](this)
        };
        this["attach"]();
        if (this["options"]["initialize"]) {
            this["options"]["initialize"]["call"](this);
        };
    },
    attach: function() {
        this["handle"]["addEvent"]("mousedown", this["bound"]["start"]);
        return this;
    },
    detach: function() {
        this["handle"]["removeEvent"]("mousedown", this["bound"]["start"]);
        return this;
    },
    start: function(event) {
        this["fireEvent"]("onBeforeStart", this["element"]);
        this["mouse"]["start"] = event["page"];
        var limit = this["options"]["limit"];
        this["limit"] = {
            "x": [],
            "y": []
        };
        for (var z in this["options"]["modifiers"]) {
            if (!this["options"]["modifiers"][z]) {
                continue;
            };
            this["value"]["now"][z] = this["element"]["getStyle"](this["options"]["modifiers"][z])["toInt"]();
            this["mouse"]["pos"][z] = event["page"][z] - this["value"]["now"][z];
            if (limit && limit[z]) {
                for (var i = 0; i < 2; i++) {
                    if (aspss.$chk(limit[z][i])) {
                        this["limit"][z][i] = limit[z][i]["apply"] ? limit[z][i]["call"](this) : limit[z][i];
                    };
                };
            };
        };
        if (aspss.$type(this["options"]["grid"]) == "number") {
            this["options"]["grid"] = {
                "x": this["options"]["grid"],
                "y": this["options"]["grid"]
            };
        };
        document["addListener"]("mousemove", this["bound"]["check"]);
        document["addListener"]("mouseup", this["bound"]["stop"]);
        this["fireEvent"]("onStart", this["element"]);
        event["stop"]();
    },
    check: function(event) {
        var distance = Math["round"](Math["sqrt"](Math["pow"](event["page"]["x"] - this["mouse"]["start"]["x"], 2) + Math["pow"](event["page"]["y"] - this["mouse"]["start"]["y"], 2)));
        if (distance > this["options"]["snap"]) {
            document["removeListener"]("mousemove", this["bound"]["check"]);
            document["addListener"]("mousemove", this["bound"]["drag"]);
            this["drag"](event);
            this["fireEvent"]("onSnap", this["element"]);
        };
        event["stop"]();
    },
    drag: function(event) {
        this["out"] = false;
        this["mouse"]["now"] = event["page"];
        for (var z in this["options"]["modifiers"]) {
            if (!this["options"]["modifiers"][z]) {
                continue;
            };
            this["value"]["now"][z] = this["mouse"]["now"][z] - this["mouse"]["pos"][z];
            if (this["limit"][z]) {
                if (aspss.$chk(this["limit"][z][1]) && (this["value"]["now"][z] > this["limit"][z][1])) {
                    this["value"]["now"][z] = this["limit"][z][1];
                    this["out"] = true;
                } else {
                    if (aspss.$chk(this["limit"][z][0]) && (this["value"]["now"][z] < this["limit"][z][0])) {
                        this["value"]["now"][z] = this["limit"][z][0];
                        this["out"] = true;
                    };
                };
            };
            if (this["options"]["grid"][z]) {
                this["value"]["now"][z] -= (this["value"]["now"][z] % this["options"]["grid"][z]);
            };
            this["element"]["setStyle"](this["options"]["modifiers"][z], this["value"]["now"][z] + this["options"]["unit"]);
        };
        this["fireEvent"]("onDrag", this["element"]);
        event["stop"]();
    },
    stop: function() {
        document["removeListener"]("mousemove", this["bound"]["check"]);
        document["removeListener"]("mousemove", this["bound"]["drag"]);
        document["removeListener"]("mouseup", this["bound"]["stop"]);
        this["fireEvent"]("onComplete", this["element"]);
    }
});
aspss["Drag"]["Base"]["implement"](new aspss.Events);
aspss["Drag"]["Base"]["implement"](new aspss.Options);
aspss["Element"]["extend"]({
    makeResizable: function(options) {
        return new aspss["Drag"].Base(this, aspss.$merge({
            modifiers: {
                x: "width",
                y: "height"
            }
        },
        options));
    }
});
aspss["Drag"]["Move"] = aspss["Drag"]["Base"]["extend"]({
    options: {
        droppables: [],
        container: false,
        overflown: []
    },
    initialize: function(el, options) {
        this["setOptions"](options);
        this["element"] = aspss.$(el);
        this["position"] = this["element"]["getStyle"]("position");
        this["droppables"] = aspss.$$(this["options"]["droppables"]);
        if (! ["absolute", "relative"]["contains"](this["position"])) {
            this["position"] = "absolute";
        };
        var top = this["element"]["getStyle"]("top")["toInt"]();
        var left = this["element"]["getStyle"]("left")["toInt"]();
        if (this["position"] == "absolute") {
            top = aspss.$chk(top) ? top: this["element"]["getTop"]();
            left = aspss.$chk(left) ? left: this["element"]["getLeft"]();
        } else {
            top = aspss.$chk(top) ? top: 0;
            left = aspss.$chk(left) ? left: 0;
        };
        this["element"]["setStyles"]({
            "top": top,
            "left": left,
            "position": this["position"]
        });
        this["parent"](this["element"], this["options"]);
    },
    start: function(event) {
        this["container"] = aspss.$(this["options"]["container"]);
        if (this["container"]) {
            var cont = this["container"]["getCoordinates"]();
            var el = this["element"]["getCoordinates"]();
            if (this["position"] == "absolute") {
                this["options"]["limit"] = {
                    "x": [cont["left"], cont["right"] - el["width"]],
                    "y": [cont["top"], cont["bottom"] - el["height"]]
                };
            } else {
                var diffx = el["left"] - this["element"]["getStyle"]("left")["toInt"]();
                var diffy = el["top"] - this["element"]["getStyle"]("top")["toInt"]();
                this["options"]["limit"] = {
                    "y": [ - (diffy) + cont["top"], cont["bottom"] - diffy - el["height"]],
                    "x": [ - (diffx) + cont["left"], cont["right"] - diffx - el["width"]]
                };
            };
        };
        this["parent"](event);
    },
    drag: function(event) {
        this["parent"](event);
        if (this["out"]) {
            return this;
        };
        this["droppables"]["each"](function(drop) {
            if (this["checkAgainst"](aspss.$(drop))) {
                if (!drop["overing"]) {
                    drop["fireEvent"]("over", [this["element"], this]);
                };
                drop["overing"] = true;
            } else {
                if (drop["overing"]) {
                    drop["fireEvent"]("leave", [this["element"], this]);
                };
                drop["overing"] = false;
            };
        },
        this);
        return this;
    },
    checkAgainst: function(el) {
        el = el["getCoordinates"](this["options"]["overflown"]);
        return (this["mouse"]["now"]["x"] > el["left"] && this["mouse"]["now"]["x"] < el["right"] && this["mouse"]["now"]["y"] < el["bottom"] && this["mouse"]["now"]["y"] > el["top"]);
    },
    stop: function() {
        if (!this["out"]) {
            var dropped = false;
            this["droppables"]["each"](function(drop) {
                if (this["checkAgainst"](drop)) {
                    drop["fireEvent"]("drop", [this["element"], this]);
                    dropped = true;
                };
            },
            this);
            if (!dropped) {
                this["element"]["fireEvent"]("emptydrop", this);
            };
        };
        this["parent"]();
        return this;
    }
});
aspss["Element"]["extend"]({
    makeDraggable: function(options) {
        return new aspss["Drag"].Move(this, options);
    }
});
aspss["XHR"] = new aspss.Class({
    options: {
        method: "post",
        async: true,
        onRequest: aspss["Class"]["empty"],
        onSuccess: aspss["Class"]["empty"],
        onFailure: aspss["Class"]["empty"],
        urlEncoded: true,
        encoding: "utf-8",
        autoCancel: false,
        headers: {}
    },
    initialize: function(options) {
        this["transport"] = (window["XMLHttpRequest"]) ? new XMLHttpRequest() : (window["ie"] ? new ActiveXObject("Microsoft.XMLHTTP") : false);
        if (!this["transport"]) {
            return;
        };
        this["setOptions"](options);
        this["options"]["isSuccess"] = this["options"]["isSuccess"] || this["isSuccess"];
        this["headers"] = {};
        if (this["options"]["urlEncoded"] && this["options"]["method"] == "post") {
            var encoding = (this["options"]["encoding"]) ? "; charset=" + this["options"]["encoding"] : "";
            this["setHeader"]("Content-type", "application/x-www-form-urlencoded" + encoding);
        };
        if (this["options"]["initialize"]) {
            this["options"]["initialize"]["call"](this);
        };
    },
    onStateChange: function() {
        if (this["transport"]["readyState"] != 4 || !this["running"]) {
            return;
        };
        this["running"] = false;
        var status = 0;
        try {
            status = this["transport"]["status"];
        } catch(e) {};
        if (this["options"]["isSuccess"]["call"](this, status)) {
            this["onSuccess"]();
        } else {
            this["onFailure"]();
        };
        this["transport"]["onreadystatechange"] = aspss["Class"]["empty"];
    },
    isSuccess: function(status) {
        return ((status >= 200) && (status < 300));
    },
    onSuccess: function() {
        this["response"] = {
            "text": this["transport"]["responseText"],
            "xml": this["transport"]["responseXML"]
        };
        this["fireEvent"]("onSuccess", [this["response"]["text"], this["response"]["xml"]]);
        this["callChain"]();
    },
    onFailure: function() {
        this["fireEvent"]("onFailure", this["transport"]);
    },
    setHeader: function(name, value) {
        this["headers"][name] = value;
        return this;
    },
    send: function(url, data) {
        if (this["options"]["autoCancel"]) {
            this["cancel"]();
        } else {
            if (this["running"]) {
                return this;
            };
        };
        this["running"] = true;
        if (data && this["options"]["method"] == "get") {
            url = url + (url["contains"]("?") ? "\x26": "?") + data;
        };
        data = null;
        (function() {
            this["transport"]["open"](this["options"]["method"], url, this["options"]["async"]);
            this["transport"]["onreadystatechange"] = this["onStateChange"]["bind"](this);
            if ((this["options"]["method"] == "post") && this["transport"]["overrideMimeType"]) {
                this["setHeader"]("Connection", "close");
            };
            aspss.$extend(this["headers"], this["options"]["headers"]);
            for (var type in this["headers"]) {
                try {
                    this["transport"]["setRequestHeader"](type, this["headers"][type]);
                } catch(e) {};
            };
            this["fireEvent"]("onRequest");
            this["transport"]["send"](aspss.$pick(data, null));
        })["delay"](this["options"]["async"] ? 1 : false, this);
        return this;
    },
    cancel: function() {
        if (!this["running"]) {
            return this;
        };
        this["running"] = false;
        this["transport"]["abort"]();
        this["transport"]["onreadystatechange"] = aspss["Class"]["empty"];
        this["fireEvent"]("onCancel");
        return this;
    }
});
aspss["XHR"]["implement"](new aspss.Chain);
aspss["XHR"]["implement"](new aspss.Events);
aspss["XHR"]["implement"](new aspss.Options);
aspss["Ajax"] = aspss["XHR"]["extend"]({
    options: {
        data: null,
        update: null,
        onComplete: aspss["Class"]["empty"],
        evalScripts: false,
        evalResponse: false
    },
    initialize: function(url, options) {
        this["addEvent"]("onSuccess", this["onComplete"]);
        this["setOptions"](options);
        this["options"]["data"] = this["options"]["data"] || this["options"]["postBody"];
        if (! ["post", "get"]["contains"](this["options"]["method"])) {
            this["_method"] = "_method=" + this["options"]["method"];
            this["options"]["method"] = "post";
        };
        this["parent"](this["options"]);
        this["setHeader"]("X-Requested-With", "XMLHttpRequest");
        this["setHeader"]("Accept", "text/javascript, text/html, application/xml, text/xml, */*");
        this["url"] = url;
    },
    onComplete: function() {
        if (this["options"]["update"]) {
            aspss.$(this["options"]["update"])["setHTML"](this["response"]["text"]);
        };
        if (this["options"]["evalScripts"] || this["options"]["evalResponse"]) {
            this["evalScripts"]();
        };
        this["fireEvent"]("onComplete", [this["response"]["text"], this["response"]["xml"]], 20);
    },
    request: function(data) {
        data = data || this["options"]["data"];
        switch (aspss.$type(data)) {
        case "element":
            data = aspss.$(data)["toQueryString"]();
            break;;
        case "object":
            data = Object["toQueryString"](data);;
        };
        if (this["_method"]) {
            data = (data) ? [this["_method"], data]["join"]("\x26") : this["_method"];
        };
        return this["send"](this["url"], data);
    },
    evalScripts: function() {
        if (this["options"]["evalResponse"] || /(ecma|java)script/ ["test"](this["getHeader"]("Content-type"))) {
            var scripts = this["response"]["text"];
        } else {
            var script, scripts = [],
            regexp = /<script[^>]*>([\s\S]*?)<\/script>/gi;
            while ((script = regexp["exec"](this["response"]["text"]))) {
                scripts["push"](script[1]);
            };
            scripts = scripts["join"]("\x0A");
        };
        if (scripts) { (window["execScript"]) ? window["execScript"](scripts) : window["setTimeout"](scripts, 0);
        };
    },
    getHeader: function(name) {
        try {
            return this["transport"]["getResponseHeader"](name);
        } catch(e) {};
        return null;
    }
});
Object["toQueryString"] = function(source) {
    var queryString = [];
    for (var property in source) {
        queryString["push"](encodeURIComponent(property) + "=" + encodeURIComponent(source[property]));
    };
    return queryString["join"]("\x26");
};
aspss["Element"]["extend"]({
    send: function(options) {
        return new aspss.Ajax(this["getProperty"]("action"), aspss.$merge({
            postBody: this["toQueryString"]()
        },
        options, {
            method: "post"
        }))["request"]();
    }
});
aspss["Cookie"] = new aspss.Abstract({
    options: {
        domain: false,
        path: false,
        duration: false,
        secure: false
    },
    set: function(key, value, options) {
        options = aspss.$merge(this["options"], options);
        value = encodeURIComponent(value);
        if (options["domain"]) {
            value += "; domain=" + options["domain"];
        };
        if (options["path"]) {
            value += "; path=" + options["path"];
        };
        if (options["duration"]) {
            var date = new Date();
            date["setTime"](date["getTime"]() + options["duration"] * 1000);
            value += "; expires=" + date["toGMTString"]();
        };
        if (options["secure"]) {
            value += "; secure";
        };
        document["cookie"] = key + "=" + value;
        return aspss.$extend(options, {
            "key": key,
            "value": value
        });
    },
    get: function(key) {
        var value = document["cookie"]["match"]("(?:^|;)\x5Cs*" + key["escapeRegExp"]() + "=([^;]*)");
        return value ? decodeURIComponent(value[1]) : false;
    },
    remove: function(cookie, options) {
        if (aspss.$type(cookie) == "object") {
            this["set"](cookie["key"], "", aspss.$merge(cookie, {
                duration: -1
            }));
        } else {
            this["set"](cookie, "", aspss.$merge(options, {
                duration: -1
            }));
        };
    }
});
aspss["Cookie"]["Json"] = new aspss.Class({
    initialize: function(name, options) {
        this["name"] = name;
        this["options"] = options;
        return;
    },
    set: function(key, value) {
        var object = this["get"]() || {};
        object[key] = value;
        this["save"](object);
        return this;
    },
    save: function(object) {
        object = aspss["Json"].toString(object);
        if (object["length"] > 4096) {
            return false;
        };
        aspss["Cookie"]["set"](this["name"], object, this["options"]);
        return this;
    },
    remove: function(key) {
        var object = this["get"]();
        delete object[key];
        this["save"](object);
        return this;
    },
    get: function(key) {
        var value = aspss["Cookie"]["get"](this["name"]);
        if (value && !value["test"](/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/)) {
            var object = aspss["Json"]["evaluate"](value);
            return (key) ? object[key] : object;
        } else {
            return false;
        };
    },
    empty: function() {
        this["save"](null);
    },
    merge: function(obj) {
        this["save"](aspss.$merge(this["get"](), obj));
    },
    fill: function(obj) {
        this["save"](aspss.$merge(obj, this["get"]()));
    }
});
aspss["Json"] = {
    toString: function(obj) {
        switch (aspss.$type(obj)) {
        case "string":
            return "\x22" + obj["replace"](/(["\\])/g, "\x5C$1") + "\x22";;
        case "array":
            return "[" + obj["map"](function(ar) {
                return aspss["Json"].toString(ar);
            })["join"](",") + "]";;
        case "object":
            var string = [];
            for (var property in obj) {
                string["push"](aspss["Json"].toString(property) + ":" + aspss["Json"].toString(obj[property]));
            };
            return "{" + string["join"](",") + "}";;
        };
        return String(obj);
    },
    evaluate: function(str) {
        return eval("(" + str + ")");
    }
};
aspss["Json"]["Remote"] = aspss["XHR"]["extend"]({
    initialize: function(url, options) {
        this["url"] = url;
        this["addEvent"]("onSuccess", this["onComplete"]);
        this["parent"](options);
        this["setHeader"]("X-Request", "JSON");
    },
    send: function(obj) {
        return this["parent"](this["url"], "json=" + aspss["Json"].toString(obj));
    },
    onComplete: function() {
        this["fireEvent"]("onComplete", aspss["Json"]["evaluate"](this["response"]["text"]));
    }
});
aspss["Asset"] = new aspss.Abstract({
    javascript: function(source, properties) {
        properties = aspss.$merge({
            "onload": aspss["Class"]["empty"]
        },
        properties);
        var script = new aspss.Element("script", {
            "src": source
        })["addEvents"]({
            "load": properties["onload"],
            "readystatechange": function() {
                if (this["readyState"] == "complete") {
                    this["fireEvent"]("load");
                };
            }
        });
        delete properties["onload"];
        return script["setProperties"](properties)["inject"](document["head"]);
    },
    css: function(source, properties) {
        return new aspss.Element("link", aspss.$merge({
            "rel": "stylesheet",
            "media": "screen",
            "type": "text/css",
            "href": source
        },
        properties))["inject"](document["head"]);
    },
    image: function(source, properties) {
        properties = aspss.$merge({
            "onload": aspss["Class"]["empty"],
            "onabort": aspss["Class"]["empty"],
            "onerror": aspss["Class"]["empty"]
        },
        properties);
        var image = new Image();
        image["src"] = source;
        var element = new aspss.Element("img", {
            "src": source
        });
        ["load", "abort", "error"]["each"](function(type) {
            var event = properties["on" + type];
            delete properties["on" + type];
            element["addEvent"](type,
            function() {
                this["removeEvent"](type, arguments["callee"]);
                event["call"](this);
            });
        });
        if (image["width"] && image["height"]) {
            element["fireEvent"]("load");
        };
        return element["setProperties"](properties);
    },
    images: function(sources, options) {
        options = aspss.$merge({
            onComplete: aspss["Class"]["empty"],
            onProgress: aspss["Class"]["empty"]
        },
        options);
        if (!sources["push"]) {
            sources = [sources];
        };
        var images = [];
        var counter = 0;
        sources["each"](function(source) {
            var img = new aspss["Asset"]["image"](source, {
                "onload": function() {
                    options["onProgress"]["call"](this, counter);
                    counter++;
                    if (counter == sources["length"]) {
                        options["onComplete"]();
                    };
                }
            });
            images["push"](img);
        });
        return aspss.$extend(images, new aspss.Elements);
    }
});
aspss["Hash"] = new aspss.Class({
    length: 0,
    initialize: function(obj) {
        this["obj"] = {};
        this["extend"](obj);
    },
    get: function(key) {
        return this["obj"][key];
    },
    hasKey: function(key) {
        return (keyinthis["obj"]);
    },
    set: function(key, value) {
        if (keyinthis["obj"]) {
            this["length"]++;
        };
        this["obj"][key] = value;
        return this;
    },
    remove: function(key) {
        if (! (keyinthis["obj"])) {
            return this;
        };
        delete this["obj"][key];
        this["length"]--;
        return this;
    },
    each: function(fn, bind) {
        aspss.$each(this["obj"], fn, bind);
    },
    extend: function(obj) {
        for (var key in obj) {
            this["set"](key, obj[key]);
        };
        return this;
    },
    empty: function() {
        this["obj"] = {};
        this["length"] = 0;
        return this;
    },
    keys: function() {
        var keys = [];
        for (var property in this["obj"]) {
            keys["push"](property);
        };
        return keys;
    },
    values: function() {
        var values = [];
        for (var property in this["obj"]) {
            values["push"](this["obj"][property]);
        };
        return values;
    }
});
aspss["$H"] = function(obj) {
    return new aspss.Hash(obj);
};
aspss["Color"] = new aspss.Class({
    initialize: function(color, type) {
        type = type || (color["push"] ? "rgb": "hex");
        var rgb, hsb;
        switch (type) {
        case "rgb":
            rgb = color;
            hsb = rgb["rgbToHsb"]();
            break;;
        case "hsb":
            rgb = color["hsbToRgb"]();
            hsb = color;
            break;;
        default:
            rgb = color["hexToRgb"](true);
            hsb = rgb["rgbToHsb"]();;
        };
        rgb["hsb"] = hsb;
        rgb["hex"] = rgb["rgbToHex"]();
        return aspss.$extend(rgb, aspss["Color"]["prototype"]);
    },
    mix: function() {
        var colors = aspss.$A(arguments);
        var alpha = (aspss.$type(colors[colors["length"] - 1]) == "number") ? colors["pop"]() : 50;
        var rgb = this["copy"]();
        colors["each"](function(color) {
            color = new aspss.Color(color);
            for (var i = 0; i < 3; i++) {
                rgb[i] = Math["round"]((rgb[i] / 100 * (100 - alpha)) + (color[i] / 100 * alpha));
            };
        });
        return new aspss.Color(rgb, "rgb");
    },
    invert: function() {
        return new aspss.Color(this["map"](function(value) {
            return 255 - value;
        }));
    },
    setHue: function(value) {
        return new aspss.Color([value, this["hsb"][1], this["hsb"][2]], "hsb");
    },
    setSaturation: function(percent) {
        return new aspss.Color([this["hsb"][0], percent, this["hsb"][2]], "hsb");
    },
    setBrightness: function(percent) {
        return new aspss.Color([this["hsb"][0], this["hsb"][1], percent], "hsb");
    }
});
aspss["$RGB"] = function(r, g, b) {
    return new aspss.Color([r, g, b], "rgb");
};
aspss["$HSB"] = function(h, s, b) {
    return new aspss.Color([h, s, b], "hsb");
};
Array["extend"]({
    rgbToHsb: function() {
        var red = this[0],
        green = this[1],
        blue = this[2];
        var hue, saturation, brightness;
        var max = Math["max"](red, green, blue),
        min = Math["min"](red, green, blue);
        var delta = max - min;
        brightness = max / 255;
        saturation = (max != 0) ? delta / max: 0;
        if (saturation == 0) {
            hue = 0;
        } else {
            var rr = (max - red) / delta;
            var gr = (max - green) / delta;
            var br = (max - blue) / delta;
            if (red == max) {
                hue = br - gr;
            } else {
                if (green == max) {
                    hue = 2 + rr - br;
                } else {
                    hue = 4 + gr - rr;
                };
            };
            hue /= 6;
            if (hue < 0) {
                hue++;
            };
        };
        return [Math["round"](hue * 360), Math["round"](saturation * 100), Math["round"](brightness * 100)];
    },
    hsbToRgb: function() {
        var br = Math["round"](this[2] / 100 * 255);
        if (this[1] == 0) {
            return [br, br, br];
        } else {
            var hue = this[0] % 360;
            var f = hue % 60;
            var p = Math["round"]((this[2] * (100 - this[1])) / 10000 * 255);
            var q = Math["round"]((this[2] * (6000 - this[1] * f)) / 600000 * 255);
            var t = Math["round"]((this[2] * (6000 - this[1] * (60 - f))) / 600000 * 255);
            switch (Math["floor"](hue / 60)) {
            case 0:
                return [br, t, p];;
            case 1:
                return [q, br, p];;
            case 2:
                return [p, br, t];;
            case 3:
                return [p, q, br];;
            case 4:
                return [t, p, br];;
            case 5:
                return [br, p, q];;
            };
        };
        return false;
    }
});
aspss["Scroller"] = new aspss.Class({
    options: {
        area: 20,
        velocity: 1,
        onChange: function(x, y) {
            this["element"]["scrollTo"](x, y);
        }
    },
    initialize: function(element, options) {
        this["setOptions"](options);
        this["element"] = aspss.$(element);
        this["mousemover"] = ([window, document]["contains"](element)) ? aspss.$(document["body"]) : this["element"];
    },
    start: function() {
        this["coord"] = this["getCoords"]["bindWithEvent"](this);
        this["mousemover"]["addListener"]("mousemove", this["coord"]);
    },
    stop: function() {
        this["mousemover"]["removeListener"]("mousemove", this["coord"]);
        this["timer"] = aspss.$clear(this["timer"]);
    },
    getCoords: function(event) {
        this["page"] = (this["element"] == window) ? event["client"] : event["page"];
        if (!this["timer"]) {
            this["timer"] = this["scroll"]["periodical"](50, this);
        };
    },
    scroll: function() {
        var el = this["element"]["getSize"]();
        var pos = this["element"]["getPosition"]();
        var change = {
            "x": 0,
            "y": 0
        };
        for (var z in this["page"]) {
            if (this["page"][z] < (this["options"]["area"] + pos[z]) && el["scroll"][z] != 0) {
                change[z] = (this["page"][z] - this["options"]["area"] - pos[z]) * this["options"]["velocity"];
            } else {
                if (this["page"][z] + this["options"]["area"] > (el["size"][z] + pos[z]) && el["scroll"][z] + el["size"][z] != el["scrollSize"][z]) {
                    change[z] = (this["page"][z] - el["size"][z] + this["options"]["area"] - pos[z]) * this["options"]["velocity"];
                };
            };
        };
        if (change["y"] || change["x"]) {
            this["fireEvent"]("onChange", [el["scroll"]["x"] + change["x"], el["scroll"]["y"] + change["y"]]);
        };
    }
});
aspss["Scroller"]["implement"](new aspss.Events);
aspss["Scroller"]["implement"](new aspss.Options);
aspss["Slider"] = new aspss.Class({
    options: {
        onChange: aspss["Class"]["empty"],
        onComplete: aspss["Class"]["empty"],
        onTick: function(pos) {
            this["knob"]["setStyle"](this["p"], pos);
        },
        mode: "horizontal",
        steps: 100,
        offset: 0
    },
    initialize: function(el, knob, options) {
        this["element"] = aspss.$(el);
        this["knob"] = aspss.$(knob);
        this["setOptions"](options);
        this["previousChange"] = -1;
        this["previousEnd"] = -1;
        this["step"] = -1;
        this["element"]["addEvent"]("mousedown", this["clickedElement"]["bindWithEvent"](this));
        var mod, offset;
        if (this["options"]["mode"] == "horizontal") {
            this["z"] = "x";
            this["p"] = "left";
            mod = {
                "x": "left",
                "y": false
            };
            offset = "offsetWidth";
        } else {
            if (this["options"]["mode"] == "vertical") {
                this["z"] = "y";
                this["p"] = "top";
                mod = {
                    "x": false,
                    "y": "top"
                };
                offset = "offsetHeight";
            };
        };
        this["max"] = this["element"][offset] - this["knob"][offset] + (this["options"]["offset"] * 2);
        this["half"] = this["knob"][offset] / 2;
        this["getPos"] = this["element"]["get" + this["p"]["capitalize"]()]["bind"](this["element"]);
        this["knob"]["setStyle"]("position", "relative")["setStyle"](this["p"], -this["options"]["offset"]);
        var lim = {};
        lim[this["z"]] = [ - this["options"]["offset"], this["max"] - this["options"]["offset"]];
        this["drag"] = new aspss["Drag"].Base(this["knob"], {
            limit: lim,
            modifiers: mod,
            snap: 0,
            onStart: function() {
                this["draggedKnob"]();
            } ["bind"](this),
            onDrag: function() {
                this["draggedKnob"]();
            } ["bind"](this),
            onComplete: function() {
                this["draggedKnob"]();
                this["end"]();
            } ["bind"](this)
        });
        if (this["options"]["initialize"]) {
            this["options"]["initialize"]["call"](this);
        };
    },
    set: function(step) {
        if (step > this["options"]["steps"]) {
            step = this["options"]["steps"];
        } else {
            if (step < 0) {
                step = 0;
            };
        };
        this["step"] = step;
        this["checkStep"]();
        this["end"]();
        this["fireEvent"]("onTick", this["toPosition"](this["step"]));
        return this;
    },
    clickedElement: function(event) {
        var position = event["page"][this["z"]] - this["getPos"]() - this["half"];
        if (position > this["max"] - this["options"]["offset"]) {
            position = this["max"] - this["options"]["offset"];
        } else {
            if (position < -this["options"]["offset"]) {
                position = -this["options"]["offset"];
            };
        };
        this["step"] = this["toStep"](position);
        this["checkStep"]();
        this["end"]();
        this["fireEvent"]("onTick", position);
    },
    draggedKnob: function() {
        this["step"] = this["toStep"](this["drag"]["value"]["now"][this["z"]]);
        this["checkStep"]();
    },
    checkStep: function() {
        if (this["previousChange"] != this["step"]) {
            this["previousChange"] = this["step"];
            this["fireEvent"]("onChange", this["step"]);
        };
    },
    end: function() {
        if (this["previousEnd"] !== this["step"]) {
            this["previousEnd"] = this["step"];
            this["fireEvent"]("onComplete", this["step"] + "");
        };
    },
    toStep: function(position) {
        return Math["round"]((position + this["options"]["offset"]) / this["max"] * this["options"]["steps"]);
    },
    toPosition: function(step) {
        return (this["max"]) * step / this["options"]["steps"];
    }
});
aspss["Slider"]["implement"](new aspss.Events);
aspss["Slider"]["implement"](new aspss.Options);
aspss["SmoothScroll"] = aspss["Fx"]["Scroll"]["extend"]({
    initialize: function(options) {
        this["parent"](window, options);
        this["links"] = (this["options"]["links"]) ? aspss.$$(this["options"]["links"]) : aspss.$$(document["links"]);
        this["addEvent"]("onCancel", this["clearChain"]);
        var location = window["location"]["href"]["match"](/^[^#]*/)[0] + "#";
        this["links"]["each"](function(link) {
            if (link["href"]["indexOf"](location) != 0) {
                return;
            };
            var anchor = link["href"]["substr"](location["length"]);
            if (anchor && aspss.$(anchor)) {
                this["useLink"](link, anchor);
            };
        },
        this);
    },
    useLink: function(link, anchor) {
        link["addEvent"]("click",
        function(event) {
            if (!window["khtml"]) {
                this["clearChain"]();
                this["chain"](function() {
                    window["location"]["hash"] = anchor;
                });
            };
            this["toElement"](anchor);
            event["stop"]();
        } ["bindWithEvent"](this));
    }
});
aspss["Sortables"] = new aspss.Class({
    options: {
        handles: false,
        onStart: aspss["Class"]["empty"],
        onComplete: aspss["Class"]["empty"],
        ghost: true,
        snap: 3,
        onDragStart: function(element, ghost) {
            ghost["setStyle"]("opacity", 0.7);
            element["setStyle"]("opacity", 0.7);
        },
        onDragComplete: function(element, ghost) {
            element["setStyle"]("opacity", 1);
            ghost["remove"]();
            this["trash"]["remove"]();
        }
    },
    initialize: function(list, options) {
        this["setOptions"](options);
        this["list"] = aspss.$(list);
        this["elements"] = this["list"]["getChildren"]();
        this["handles"] = (this["options"]["handles"]) ? aspss.$$(this["options"]["handles"]) : this["elements"];
        this["bound"] = {
            "start": [],
            "moveGhost": this["moveGhost"]["bindWithEvent"](this)
        };
        for (var i = 0, l = this["handles"]["length"]; i < l; i++) {
            this["bound"]["start"][i] = this["start"]["bindWithEvent"](this, this["elements"][i]);
        };
        this["attach"]();
        if (this["options"]["initialize"]) {
            this["options"]["initialize"]["call"](this);
        };
        this["bound"]["move"] = this["move"]["bindWithEvent"](this);
        this["bound"]["end"] = this["end"]["bind"](this);
    },
    attach: function() {
        this["handles"]["each"](function(handle, i) {
            handle["addEvent"]("mousedown", this["bound"]["start"][i]);
        },
        this);
    },
    detach: function() {
        this["handles"]["each"](function(handle, i) {
            handle["removeEvent"]("mousedown", this["bound"]["start"][i]);
        },
        this);
    },
    start: function(event, el) {
        this["active"] = el;
        this["coordinates"] = this["list"]["getCoordinates"]();
        if (this["options"]["ghost"]) {
            var position = el["getPosition"]();
            this["offset"] = event["page"]["y"] - position["y"];
            this["trash"] = new aspss.Element("div")["inject"](document["body"]);
            this["ghost"] = el["clone"]()["inject"](this["trash"])["setStyles"]({
                "position": "absolute",
                "left": position["x"],
                "top": event["page"]["y"] - this["offset"]
            });
            document["addListener"]("mousemove", this["bound"]["moveGhost"]);
            this["fireEvent"]("onDragStart", [el, this["ghost"]]);
        };
        document["addListener"]("mousemove", this["bound"]["move"]);
        document["addListener"]("mouseup", this["bound"]["end"]);
        this["fireEvent"]("onStart", el);
        event["stop"]();
    },
    moveGhost: function(event) {
        var value = event["page"]["y"] - this["offset"];
        if (value < this["coordinates"]["top"]) {
            value = this["coordinates"]["top"];
        } else {
            if (value + this["ghost"]["offsetHeight"] > this["coordinates"]["bottom"]) {
                value = this["coordinates"]["bottom"] - this["ghost"]["offsetHeight"];
            };
        };
        this["ghost"]["setStyle"]("top", value);
        event["stop"]();
    },
    move: function(event) {
        this["active"]["active"] = true;
        this["previous"] = this["previous"] || event["page"]["y"];
        this["now"] = event["page"]["y"];
        var direction = ((this["previous"] - this["now"]) <= 0) ? "down": "up";
        var prev = this["active"]["getPrevious"]();
        var next = this["active"]["getNext"]();
        if (prev && direction == "up") {
            var prevPos = prev["getCoordinates"]();
            if (event["page"]["y"] < prevPos["bottom"]) {
                this["active"]["injectBefore"](prev);
            };
        };
        if (next && direction == "down") {
            var nextPos = next["getCoordinates"]();
            if (event["page"]["y"] > nextPos["top"]) {
                this["active"]["injectAfter"](next);
            };
        };
        this["previous"] = event["page"]["y"];
    },
    serialize: function() {
        var serial = [];
        this["list"]["getChildren"]()["each"](function(el, i) {
            serial[i] = this["elements"]["indexOf"](el);
        },
        this);
        return serial;
    },
    end: function() {
        this["previous"] = null;
        document["removeListener"]("mousemove", this["bound"]["move"]);
        document["removeListener"]("mouseup", this["bound"]["end"]);
        if (this["options"]["ghost"]) {
            document["removeListener"]("mousemove", this["bound"]["moveGhost"]);
            this["fireEvent"]("onDragComplete", [this["active"], this["ghost"]]);
        };
        this["fireEvent"]("onComplete", this["active"]);
    }
});
aspss["Sortables"]["implement"](new aspss.Events);
aspss["Sortables"]["implement"](new aspss.Options);
aspss["Tips"] = new aspss.Class({
    options: {
        onShow: function(tip) {
            tip["setStyle"]("visibility", "visible");
        },
        onHide: function(tip) {
            tip["setStyle"]("visibility", "hidden");
        },
        maxTitleChars: 30,
        showDelay: 100,
        hideDelay: 100,
        className: "tool",
        offsets: {
            "x": 16,
            "y": 16
        },
        fixed: false
    },
    initialize: function(elements, options) {
        this["setOptions"](options);
        this["toolTip"] = new aspss.Element("div", {
            "class": this["options"]["className"] + "-tip",
            "styles": {
                "position": "absolute",
                "top": "0",
                "left": "0",
                "visibility": "hidden"
            }
        })["inject"](document["body"]);
        this["wrapper"] = new aspss.Element("div")["inject"](this["toolTip"]);
        aspss.$each(elements,
        function(el) {
            this["build"](aspss.$(el));
        },
        this);
        if (this["options"]["initialize"]) {
            this["options"]["initialize"]["call"](this);
        };
    },
    build: function(el) {
        el["$"]["myTitle"] = (el["href"] && el["getTag"]() == "a") ? el["href"]["replace"]("http://", "") : (el["rel"] || false);
        if (el["title"]) {
            var dual = el["title"]["split"]("::");
            if (dual["length"] > 1) {
                el["$"]["myTitle"] = dual[0]["trim"]();
                el["$"]["myText"] = dual[1]["trim"]();
            } else {
                el["$"]["myText"] = el["title"];
            };
            el["removeAttribute"]("title");
        } else {
            el["$"]["myText"] = false;
        };
        if (el["$"]["myTitle"] && el["$"]["myTitle"]["length"] > this["options"]["maxTitleChars"]) {
            el["$"]["myTitle"] = el["$"]["myTitle"]["substr"](0, this["options"]["maxTitleChars"] - 1) + "\x26hellip;";
        };
        el["addEvent"]("mouseenter",
        function(event) {
            this["start"](el);
            if (!this["options"]["fixed"]) {
                this["locate"](event);
            } else {
                this["position"](el);
            };
        } ["bind"](this));
        if (!this["options"]["fixed"]) {
            el["addEvent"]("mousemove", this["locate"]["bindWithEvent"](this));
        };
        el["addEvent"]("mouseleave", this["end"]["bind"](this));
    },
    start: function(el) {
        this["wrapper"]["empty"]();
        if (el["$"]["myTitle"]) {
            this["title"] = new aspss.Element("span")["inject"](new aspss.Element("div", {
                "class": this["options"]["className"] + "-title"
            })["inject"](this["wrapper"]))["setHTML"](el["$"]["myTitle"]);
        };
        if (el["$"]["myText"]) {
            this["text"] = new aspss.Element("span")["inject"](new aspss.Element("div", {
                "class": this["options"]["className"] + "-text"
            })["inject"](this["wrapper"]))["setHTML"](el["$"]["myText"]);
        };
        aspss.$clear(this["timer"]);
        this["timer"] = this["show"]["delay"](this["options"]["showDelay"], this);
    },
    end: function(event) {
        aspss.$clear(this["timer"]);
        this["timer"] = this["hide"]["delay"](this["options"]["hideDelay"], this);
    },
    position: function(element) {
        var pos = element["getPosition"]();
        this["toolTip"]["setStyles"]({
            "left": pos["x"] + this["options"]["offsets"]["x"],
            "top": pos["y"] + this["options"]["offsets"]["y"]
        });
    },
    locate: function(event) {
        var win = {
            "x": window["getWidth"](),
            "y": window["getHeight"]()
        };
        var scroll = {
            "x": window["getScrollLeft"](),
            "y": window["getScrollTop"]()
        };
        var tip = {
            "x": this["toolTip"]["offsetWidth"],
            "y": this["toolTip"]["offsetHeight"]
        };
        var prop = {
            "x": "left",
            "y": "top"
        };
        for (var z in prop) {
            var pos = event["page"][z] + this["options"]["offsets"][z];
            if ((pos + tip[z] - scroll[z]) > win[z]) {
                pos = event["page"][z] - this["options"]["offsets"][z] - tip[z];
            };
            this["toolTip"]["setStyle"](prop[z], pos);
        };
    },
    show: function() {
        this["fireEvent"]("onShow", [this["toolTip"]]);
    },
    hide: function() {
        this["fireEvent"]("onHide", [this["toolTip"]]);
    }
});
aspss["Tips"]["implement"](new aspss.Events);
aspss["Tips"]["implement"](new aspss.Options);
aspss["Group"] = new aspss.Class({
    initialize: function() {
        this["instances"] = aspss.$A(arguments);
        this["events"] = {};
        this["checker"] = {};
    },
    addEvent: function(type, fn) {
        this["checker"][type] = this["checker"][type] || {};
        this["events"][type] = this["events"][type] || [];
        if (this["events"][type]["contains"](fn)) {
            return false;
        } else {
            this["events"][type]["push"](fn);
        };
        this["instances"]["each"](function(instance, i) {
            instance["addEvent"](type, this["check"]["bind"](this, [type, instance, i]));
        },
        this);
        return this;
    },
    check: function(type, instance, i) {
        this["checker"][type][i] = true;
        var every = this["instances"]["every"](function(current, j) {
            return this["checker"][type][j] || false;
        },
        this);
        if (!every) {
            return;
        };
        this["instances"]["each"](function(current, j) {
            this["checker"][type][j] = false;
        },
        this);
        this["events"][type]["each"](function(event) {
            event["call"](this, this["instances"], instance);
        },
        this);
    }
});
aspss["Accordion"] = aspss["Fx"]["Elements"]["extend"]({
    options: {
        onActive: aspss["Class"]["empty"],
        onBackground: aspss["Class"]["empty"],
        display: 0,
        show: false,
        height: true,
        width: false,
        opacity: true,
        fixedHeight: false,
        fixedWidth: false,
        wait: false,
        alwaysHide: false
    },
    initialize: function() {
        var options, togglers, elements, container;
        aspss.$each(arguments,
        function(argument, i) {
            switch (aspss.$type(argument)) {
            case "object":
                options = argument;
                break;;
            case "element":
                container = aspss.$(argument);
                break;;
            default:
                var temp = aspss.$$(argument);
                if (!togglers) {
                    togglers = temp;
                } else {
                    elements = temp;
                };;
            };
        });
        this["togglers"] = togglers || [];
        this["elements"] = elements || [];
        this["container"] = aspss.$(container);
        this["setOptions"](options);
        this["previous"] = -1;
        if (this["options"]["alwaysHide"]) {
            this["options"]["wait"] = true;
        };
        if (aspss.$chk(this["options"]["show"])) {
            this["options"]["display"] = false;
            this["previous"] = this["options"]["show"];
        };
        if (this["options"]["start"]) {
            this["options"]["display"] = false;
            this["options"]["show"] = false;
        };
        this["effects"] = {};
        if (this["options"]["opacity"]) {
            this["effects"]["opacity"] = "fullOpacity";
        };
        if (this["options"]["width"]) {
            this["effects"]["width"] = this["options"]["fixedWidth"] ? "fullWidth": "offsetWidth";
        };
        if (this["options"]["height"]) {
            this["effects"]["height"] = this["options"]["fixedHeight"] ? "fullHeight": "scrollHeight";
        };
        for (var i = 0, l = this["togglers"]["length"]; i < l; i++) {
            this["addSection"](this["togglers"][i], this["elements"][i]);
        };
        this["elements"]["each"](function(el, i) {
            if (this["options"]["show"] === i) {
                this["fireEvent"]("onActive", [this["togglers"][i], el]);
            } else {
                for (var fx in this["effects"]) {
                    el["setStyle"](fx, 0);
                };
            };
        },
        this);
        this["parent"](this["elements"], this["options"]);
        if (aspss.$chk(this["options"]["display"])) {
            this["display"](this["options"]["display"]);
        };
    },
    addSection: function(toggler, element, pos) {
        toggler = aspss.$(toggler);
        element = aspss.$(element);
        var test = this["togglers"]["contains"](toggler);
        var len = this["togglers"]["length"];
        this["togglers"]["include"](toggler);
        this["elements"]["include"](element);
        if (len && (!test || pos)) {
            pos = aspss.$pick(pos, len - 1);
            toggler["injectBefore"](this["togglers"][pos]);
            element["injectAfter"](toggler);
        } else {
            if (this["container"] && !test) {
                toggler["inject"](this["container"]);
                element["inject"](this["container"]);
            };
        };
        var idx = this["togglers"]["indexOf"](toggler);
        toggler["addEvent"]("click", this["display"]["bind"](this, idx));
        if (this["options"]["height"]) {
            element["setStyles"]({
                "padding-top": 0,
                "border-top": "none",
                "padding-bottom": 0,
                "border-bottom": "none"
            });
        };
        if (this["options"]["width"]) {
            element["setStyles"]({
                "padding-left": 0,
                "border-left": "none",
                "padding-right": 0,
                "border-right": "none"
            });
        };
        element["fullOpacity"] = 1;
        if (this["options"]["fixedWidth"]) {
            element["fullWidth"] = this["options"]["fixedWidth"];
        };
        if (this["options"]["fixedHeight"]) {
            element["fullHeight"] = this["options"]["fixedHeight"];
        };
        element["setStyle"]("overflow", "hidden");
        if (!test) {
            for (var fx in this["effects"]) {
                element["setStyle"](fx, 0);
            };
        };
        return this;
    },
    display: function(index) {
        index = (aspss.$type(index) == "element") ? this["elements"]["indexOf"](index) : index;
        if ((this["timer"] && this["options"]["wait"]) || (index === this["previous"] && !this["options"]["alwaysHide"])) {
            return this;
        };
        this["previous"] = index;
        var obj = {};
        this["elements"]["each"](function(el, i) {
            obj[i] = {};
            if ((i != index) || (this["options"]["alwaysHide"] && (el["offsetHeight"] > 0))) {
                this["fireEvent"]("onBackground", [this["togglers"][i], el]);
                for (var fx in this["effects"]) {
                    obj[i][fx] = 0;
                };
            } else {
                this["fireEvent"]("onActive", [this["togglers"][i], el]);
                for (var fx in this["effects"]) {
                    obj[i][fx] = el[this["effects"][fx]];
                };
            };
        },
        this);
        return this["start"](obj);
    },
    showThisHideOpen: function(index) {
        return this["display"](index);
    }
});
aspss["Fx"]["Accordion"] = aspss["Accordion"];


var classASPSS=new aspss.Class(
{
  initialize:function(oInst,oSettings)
  {
    this.container=aspss.$(oInst);
    if(!this.container.hasClass('isinitialized'))
    {
      this.container.addClass('isinitialized');
      this.slides=[];
      this.buttons=[];
      this.slidetexts=[];
      this.textFx=new Array();
      this.mouseOver = false;
      this.pauseClicked = false;
      this.options=Object.extend(
                                  {
                                    sSlidesSelector:".slide",
                                    sButtonsSelector:".button",
                                    sSlidetextSelector:".slidetext",
                                    iCrossFadeDelay:4000,
                                    iTransitionDelay:700,
                                    iStartIndex:0,
                                    sButtonOnClass:"menu-active",
                                    sButtonOffClass:"off",
                                    sRotateOn:"click",
                                    sAutoStart:true,
                                    sAutoRotate:true,
                                    sPauseText:"Pause",
                                    sStartText:"Start",
                                    sTransitionDirection:"",
                                    sTransition:"bounce",
                                    sTransitionEase:"easeout",
                                    fJsPlayButtonClicked:false,
                                    fJsNextButtonClicked:false,
                                    fJsPrevButtonClicked:false,
                                    fJsMenuItemClicked:false,
                                    fJsSlideChanged:false,
                                    fStopOnMouseOver:false,
                                    stop:false
                                  }, 
                                  oSettings||{}
		                            ); 
		  
		  
      if(this.options.sTransitionDirection.length == 0){this.options.sTransition = ""; this.options.sTransitionEase = "";}
      this.slides=aspss.$(oInst).getElements(this.options.sSlidesSelector);
      this.buttons=aspss.$(oInst).getElements(this.options.sButtonsSelector);
      this.slidetexts=aspss.$$(this.options.sSlidetextSelector);
      this.createFx();
      this.showSlide(this.options.iStartIndex);
      if(this.options.sAutoStart)this.autoStart();
      if(this.options.fJsSlideChanged)ASPSS_Slide_Changed(0);
      if(this.options.sRotateOn!="")this.setupAction(this.options.sRotateOn);
      return this
      
		}else return false
	}
		,
		setupAction:function(c){
			this.buttons.each(function(a,b){aspss.$(a).addEvent(c,function(){this.slideFx.setOptions(this.slideFx.options,{duration:this.options.iTransitionDelay});if(this.currentSlide!=b)this.selected(b);if(this.options.stop){this.stop()}}.bind(this))},this);
			aspss.$(this.container.id+"_prev").addEvent(c,function(){this.prev();if(this.options.stop){aspss.$(this.container.id+"_playButton").innerHTML=this.options.sStartText;aspss.$(this.container.id+"_playButton").addClass('pause');this.stop()}}.bind(this));
			aspss.$(this.container.id+"_next").addEvent(c,function(){this.next();if(this.options.stop){aspss.$(this.container.id+"_playButton").innerHTML=this.options.sStartText;aspss.$(this.container.id+"_playButton").addClass('pause');this.stop()}}.bind(this));
			aspss.$(this.container.id+"_playButton").addEvent(c,function(){if(aspss.$(this.container.id+"_playButton").hasClass('pause')){aspss.$(this.container.id+"_playButton").innerHTML=this.options.sPauseText;aspss.$(this.container.id+"_playButton").removeClass('pause');this.autoStart()}else{aspss.$(this.container.id+"_playButton").innerHTML=this.options.sStartText;aspss.$(this.container.id+"_playButton").addClass('pause');this.stop()}}.bind(this))
		}
		,
		createFx:function(){
			this.slideFx=new aspss.Fx.Elements(this.slides,{duration:this.options.iTransitionDelay});
			this.slides.each(function(a){a.setStyle('opacity',0)});
			if(this.options.sTransitionDirection.length > 0){
			  if(this.options.sTransition != "Bounce" && this.options.sTransition != "Expo" && this.options.sTransitionEase != "Sine"){this.options.sTransition = "Linear";}
				if(this.options.sTransitionEase.length == 0){this.options.sTransitionEase = "easeOut";}else{if(this.options.sTransitionEase != "easeOut" && this.options.sTransitionEase != "easeIn" && this.options.sTransitionEase != "easeInOut" ){this.options.sTransitionEase = "easeOut";}}
				for(var i=0;i<this.slidetexts.length;i++){
					this.textFx[i]=new aspss.Fx.Slide(this.slidetexts[i],{duration:this.options.iTransitionDelay, mode:this.options.sTransitionDirection})
					if(this.options.sTransition != "Linear"){this.textFx[i].options.transition = aspss.Fx.Transitions[this.options.sTransition][this.options.sTransitionEase];}
				}
			}
		}
		,
		showSlide:function(c){ //alert("showSlide");
			if(this.options.fStopOnMouseOver && this.mouseOver)return;
			var d={};
			this.slides.each(function(a,b){a.addEvent('mouseover',function(){this.mouseOver = true}.bind(this));a.addEvent('mouseout',function(){this.mouseOver = false}.bind(this));}.bind(this));
			this.slides.each(function(a,b){if(b==c&&b!=this.currentSlide){aspss.$(this.buttons[b]).removeClass(this.options.sButtonOffClass).addClass(this.options.sButtonOnClass);d[b.toString()]={'opacity':[1]};textIndex=b}else{aspss.$(this.buttons[b]).removeClass(this.options.sButtonOnClass).addClass(this.options.sButtonOffClass);d[b.toString()]={'opacity':[0]};if(this.options.sTransition.length > 0)this.textFx[b].slideOut()}},this);
			if(this.options.fJsSlideChanged)ASPSS_Slide_Changed(c);
			this.currentSlide=c;
			this.slideFx.start(d);
			if(this.options.sTransition.length > 0){
				this.textFx[textIndex].hide();
				this.textFx[textIndex].slideIn();
			}
		}
		,
		autoStart:function(){ //alert("autoStart");
			this.slideshowInt=this.rotate.periodical(this.options.iCrossFadeDelay,this);
			if(this.pauseClicked){
			  if(this.options.fJsPlayButtonClicked)ASPSS_PlayButton_Clicked(1, this.currentSlide);
			  this.pauseClicked = false;
			}
			if(! this.options.sAutoRotate) {this.stop();}
		}
		,
		stop:function(){ //alert("stop");
			clearInterval(this.slideshowInt);
			if(this.options.fJsPlayButtonClicked)ASPSS_PlayButton_Clicked(0, this.currentSlide);
			this.pauseClicked = true;
		}
		,
		rotate:function(){ //alert("rotate");
			current=this.currentSlide;
			next=(current+1>=this.slides.length)?0:current+1;
			this.showSlide(next);
		}
		,
		next:function(){ //alert("next");
			current=this.currentSlide;
			next=(current+1>=this.slides.length)?0:current+1;
			clearInterval(this.slideshowInt);
			this.showSlide(next);
			if(this.options.fJsNextButtonClicked)ASPSS_NextButton_Clicked(next);
			this.autoStart();
		}
		,
		prev:function(){ //alert("prev");
			current=this.currentSlide;
			prev=(current-1<0)?this.slides.length-1:current-1;
			clearInterval(this.slideshowInt);
			this.showSlide(prev);
			if(this.options.fJsPrevButtonClicked)ASPSS_PrevButton_Clicked(prev);
			this.autoStart();
		}
		,
		selected:function(a){ //alert("selected");
			clearInterval(this.slideshowInt);
			this.showSlide(a);
			if(this.options.fJsMenuItemClicked)ASPSS_MenuItem_Clicked(a);
			this.autoStart();
		}
		,
		show:function(){ //alert("show");
			aspss.$(this.options.fpslideshowContainer).setStyle('visibility','visible');
			if(!aspss.$(this.options.fpslideshowContainer).visible())aspss.$(this.options.fpslideshowContainer).show()
		}
		,
		hide:function(){
			aspss.$(this.options.fpslideshowContainer).setStyle('visibility','hidden')
		}
	}
);


var _ASPSS = {
	_settingsInstances : []
	,
	init : function(settings){
	  var id = String(Math.random()).replace(".","");
		this._settingsInstances[id] = settings;
		
		window.addEvent('domready',function(){if(aspss.$(settings.SlideShowId)){setTimeout("_ASPSS.initSlideshow('"+ id +"')",settings.LoadingDelay)}});
	}
	,
	initSlideshow : function(id){
		var settings = this._settingsInstances[id];
		if(aspss.$(settings.SlideLoadingSelector))aspss.$(settings.SlideLoadingSelector).setStyle('display','none');else return;
		if(aspss.$(settings.SlideOuterSelector))aspss.$(settings.SlideOuterSelector).setStyle('display','block');else return;
		var myASPSS = new classASPSS(aspss.$(settings.SlideShowId),{
                                                            sSlidetextSelector:settings.SlideTextSelector,
                                                            sPauseText:settings.PauseText,
                                                            sStartText:settings.StartText,
                                                            iCrossFadeDelay:settings.CrossFadeDelay,
                                                            iTransitionDelay:settings.TransitionDelay,
                                                            sRotateOn:settings.RotateOn,
                                                            sAutoStart:settings.AutoStart,
                                                            sAutoRotate:settings.AutoRotate,
                                                            sTransitionDirection:settings.TextBarTransitionDirection,
                                                            sTransition:settings.TextBarTransition,
                                                            sTransitionEase:settings.TextBarTransitionEase,
                                                            fJsPlayButtonClicked:settings.JSPlayButtonClicked,
                                                            fJsNextButtonClicked:settings.JSNextButtonClicked,
                                                            fJsPrevButtonClicked:settings.JSPrevButtonClicked,
                                                            fJsMenuItemClicked:settings.JSMenuItemClicked,
                                                            fJsSlideChanged:settings.JSSlideChanged,
                                                            fStopOnMouseOver:settings.StopOnMouseOver,
                                                            stop:false})
	}

}