码迷,mamicode.com
首页 > Web开发 > 详细

ToolKit与jQuery类似的前端插件

时间:2016-06-15 19:04:55      阅读:260      评论:0      收藏:0      [点我收藏+]

标签:

优点:

丢弃了一些不常用的方法(jQuery.fn):slideUp、fadeIn、animate等;

新增获取子节点的方法(ToolKit.fn):firstChild,lastChild等;

新增ToolKit.Threads线程操作函数(有效解决自定义弹窗同时运行的问题);

加入JSON对象(JSON.parse和JSON.stringify);

重写ToolKit.toString方法为JSON.stringify,ToolKit.get和ToolKit.post的dataType为json格式,使用更方便;

代码更小,但功能一样强大,选择器、异步取数和基本方法一个都不少,最重要的是逻辑清晰,初学者都可以进行二次开发。

技术分享
(function(window) {
        var
            version = "1.1.1",

            arr = [],
            push = arr.push,
            slice = arr.slice,
            concat = arr.concat,
            indexOf = arr.indexOf || function(o, from) {
                var
                    len = this.length,
                    i = from ? from < 0 ? Math.max(0, len + from) : from : 0;
                for (; i < len; i++) {
                    if (this[i] === o) {
                        return i;
                    }
                }
                return -1;
            },

            support = {},
            class2type = {},
            toString = class2type.toString,
            hasOwn = class2type.hasOwnProperty,
            cssfix = ["Moz", "Webkit", "O", "ms"],
            cssform = {
                letterSpacing: "0",
                fontWeight: "400"
            },
            csslock = {
                position: "absolute",
                visibility: "hidden",
                display: "block"
            },

            rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
            rsingleTag = /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/,
            rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,

            rmsPrefix = /^-ms-/,
            rdashAlpha = /-([\da-z])/gi,
            fcamelCase = function(all, letter) {
                return letter.toUpperCase();
            },
            isArrayLike = function(o) {
                if (o == null) {
                    return false;
                }
                var len = o.length,
                    type = ToolKit.type(o);
                if (type === "function" || type === "string" || o.window === o || len == null) {
                    return false;
                }
                return type === "array" || len === 0 || o.nodeType === 1 || (typeof len === "number") && (len - 1 in o);
            },

            ToolKit = function(selector, context) {
                return new ToolKit.fn.init(selector, context);
            };
        ToolKit.extend = function() {
            var
                key, value, length, isArray, configs, options,
                i = 1,
                limit = false,
                len = arguments.length,
                target = arguments[0];

            if (typeof target === "boolean") {
                limit = target;
                target = arguments[i++] || {};
            }
            if (typeof target !== "object" && typeof target !== "function" && typeof target !== "array") {
                target = {};
            }
            for (; i < len; i++) {
                if (!!(options = arguments[i])) {
                    for (key in options) {
                        value = options[key];
                        configs = target[key];
                        if (value === configs || value === undefined) continue;
                        if (limit && value && (ToolKit.isPlainObject(value) || (isArray = ToolKit.isArray(value)))) {
                            target[key] = ToolKit.extend(limit, target[key] || (isArray ? [] : {}), value);
                        } else {
                            target[key] = value;
                        }
                    }
                }
            }
            return target;
        }
        ToolKit.improve = function() {
            var
                key, value, length, isArray, configs, options,
                i = 1,
                limit = false,
                len = arguments.length,
                target = arguments[0];

            if (typeof target === "boolean") {
                limit = target;
                target = arguments[i++] || {};
            }
            if (typeof target !== "object" && typeof target !== "function" && typeof target !== "array") {
                target = {};
            }
            for (; i < len; i++) {
                if (!!(options = arguments[i])) {
                    for (key in options) {
                        value = options[key];
                        configs = target[key];
                        if (value === configs || value === undefined) continue;
                        if (limit && value && (ToolKit.isPlainObject(value) || (isArray = ToolKit.isArray(value)))) {
                            target[key] = ToolKit.improve(limit, target[key] || (isArray ? [] : {}), value);
                            isArray = false;
                        } else {
                            target[key] = configs || value;
                        }
                    }
                }
            }
            return target;
        }
        ToolKit.extend(ToolKit, {
            kit: "kit",
            zIndex: 1000,
            type: function(o) {
                return o === null ? "null" : typeof o === "object" ? class2type[toString.call(o)] || "object" : typeof o;
            },
            isString: function(o) {
                return ToolKit.type(o) === "string";
            },
            isFunction: function(o) {
                return ToolKit.type(o) === "function";
            },
            isArray: Array.isArray || function(obj) {
                return ToolKit.type(obj) === "array";
            },
            isNumber: function(o) {
                return !ToolKit.isArray(0) && Math.abs(o - parseFloat(o)) >= 0;
            },
            isWindow: function(o) {
                return !!o && (o === o.window);
            },
            inArray: function(o, list, from) {
                if (ToolKit.isArray(list)) {
                    return indexOf.call(list, o, from);
                }
                return -1;
            },
            isEmptyObject: function(o) {
                for (var i in o) {
                    return false;
                }
                return true;
            },
            isPlainObject: function(o) {
                if (!o || ToolKit.type(o) !== "object" || !!o.nodeType || ToolKit.isWindow(o)) {
                    return false;
                }
                try {
                    if (o.constructor && !hasOwn.call(o, "constructor") && !hasOwn.call(o.constructor.prototype, "constructor")) {
                        return false;
                    }
                } catch (e) {
                    return false;
                }
                var key;
                for (key in o) {}
                return key === undefined || hasOwn.call(o, key);
            },
            support: support
        });
        ToolKit.extend(ToolKit, {
            error: function(msg) {
                throw new Error(msg);
            },
            syntaxError: function(msg) {
                throw new SyntaxError(msg);
            }
        });
        ToolKit.extend(ToolKit, {
            each: function(o, iterator, context) {
                var i = 0;
                if (isArrayLike(o)) {
                    for (var len = o.length; i < len; i++) {
                        if (iterator.call(context || o[i], i, o[i], o) === false) {
                            break;
                        }
                    }
                } else {
                    for (i in o) {
                        if (iterator.call(context || o[i], i, o[i], o) === false) {
                            break;
                        }
                    }
                }
                return o;
            },
            map: function(o, iterator, context) {
                var val, i = 0,
                    list = [];
                if (isArrayLike(o)) {
                    for (var len = o.length; i < len; i++) {
                        if ((val = iterator.call(context, o[i], i, o)) != null)
                            list.push(val);
                    }
                } else {
                    for (i in o) {
                        if ((val = iterator.call(context, o[i], i, o)) != null)
                            list.push(val);
                    }
                }
                return concat.apply([], list);
            },
            merge: function(to, from) {
                var i = 0,
                    l = +to.length || 0,
                    len = (from && +from.length) || -1;
                while (i < len) {
                    to[l++] = from[i++];
                }
                if (len !== len) {
                    while (from[i] !== undefined) {
                        to[l++] = from[i++];
                    }
                }
                to.length = l;
                return to;
            },
            makeArray: function(arr, results) {
                var r = results || [];
                if (arr != null) {
                    if (isArrayLike(Object(arr))) {
                        ToolKit.merge(r, typeof arr === "string" ? [arr] : arr);
                    } else {
                        push.call(r, arr);
                    }
                }
                return r;
            }
        });

        ToolKit.extend(ToolKit, {
            trim: function(string) {
                return string == null ? "" : String(string).replace(rtrim, "");
            },
            camelCase: function(string) {
                return String(string).replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
            },
            globalEval: function(code) {
                code = ToolKit.trim(code);
                if (code) {
                    if (code.indexOf("use strict") > -1) {
                        script = document.createElement("script");
                        script.text = code;
                        document.head.appendChild(script).parentNode.removeChild(script);
                    } else {
                        (window.execScript || function(data) {
                            window["eval"].call(window, data);
                        })(code);
                    }
                }
            },
            htmlPrefilter: function(html) {
                return html.replace(rxhtmlTag, "<$1></$2>");
            }
        });


        var
            rtbody = /<tbody/i,
            rhtml = /<|&#?\w+;/,
            rtagName = /<([\w:]+)/,
            rleadingWhitespace = /^\s+/,
            rscriptType = (/^$|\/(?:java|ecma)script/i),
            whitespace = "[\\x20\\t\\r\\n\\f]",
            booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
            wrapMap = {
                option: [1, "<select multiple=‘multiple‘>", "</select>"],
                legend: [1, "<fieldset>", "</fieldset>"],
                area: [1, "<map>", "</map>"],
                param: [1, "<object>", "</object>"],
                thead: [1, "<table>", "</table>"],
                tr: [2, "<table><tbody>", "</tbody></table>"],
                col: [2, "<table><tbody></tbody><colgroup>", "</colgroup></table>"],
                td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],
                _default: support.htmlSerialize ? [0, "", ""] : [1, "X<div>", "</div>"]
            },
            rwhitespace = new RegExp(whitespace + "+", "g"),
            rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*");
        wrapMap.optgroup = wrapMap.option;
        wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
        wrapMap.th = wrapMap.td;

        function buildFragment(elems, context, selection) {
            var elem, tmp, tag, wrap, index, counter,
                fragment = context.createDocumentFragment(),
                i = 0,
                list = [],
                len = elems.length;

            for (; i < len; i++) {
                elem = elems[i];
                if (elem || elem === 0) {
                    if (ToolKit.type(elem) === "object") {
                        ToolKit.merge(list, elem.nodeType ? [elem] : elem);
                    } else if (!rhtml.test(elem)) {
                        list.push(context.createTextNode(elem));
                    } else {
                        tmp = tmp || fragment.appendChild(context.createElement("div"));
                        tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
                        wrap = wrapMap[tag] || wrapMap._default;
                        tmp.innerHTML = wrap[1] + ToolKit.htmlPrefilter(elem) + wrap[2];
                        index = wrap[0];
                        while (index--) {
                            tmp = tmp.lastChild;
                        }
                        if (!support.leadingWhitespace && !!(counter = rleadingWhitespace.exec(this))) {
                            list.push(context.createTextNode(counter[0]));
                        }
                        if (!support.tbody) {
                            var xml = (tag === "table" && !rtbody.test(this)) ? tmp.firstChild : match[1] === "<table>" && !rtbody.test(this) ? tmp : 0;
                            tbody = xml && xml.childNodes.firstChild;
                            do {
                                if (ToolKit.nodeName(tbody, "tbody") && !tbody.childNodes.length) {
                                    xml.removeChild(tbody);
                                }
                            }
                            while (tbody && !!(tbody = tbody.nextSibling));
                        }
                        ToolKit.merge(list, tmp.childNodes);
                        tmp.textContent = "";
                        while (tmp.firstChild) {
                            tmp.removeChild(tmp.firstChild);
                        }
                        tmp = fragment.lastChild;
                    }
                }
            }
            if (tmp) {
                fragment.removeChild(tmp);
            }
            i = 0;
            while (!!(elem = list[i++])) {
                if (selection && ToolKit.inArray(elem, selection) !== -1) {
                    continue;
                }

                fragment.appendChild(elem);
            }
            return fragment;
        };

        ToolKit.extend(ToolKit, {
            parse: function(text, reviver) {
                return window.JOSN.parse(text, reviver);
            },
            toString: function(value, replacer, space) {
                return window.JOSN.stringify(value, replacer, space);
            },
            parseHTML: function(data, context) {
                if (!data || typeof data !== "string") {
                    return null;
                }
                context = context || document;
                var html = rsingleTag.exec(data);
                if (html) {
                    return [context.createElement(html[1])];
                }
                html = buildFragment([data], context);
                return ToolKit.merge([], html.childNodes);
            }
        });

        ToolKit.each(["Boolean", "Number", "String", "Function", "Array", "Date", "RegExp", "Error", "Object", "Document", "Symbol"], function() {
            class2type["[object " + this + "]"] = this.toLowerCase();
        });

        (function($) {
            var
                cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
                escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
                indent,
                iterator,
                target = ‘‘,
                meta = {
                    ‘\b‘: ‘\\b‘,
                    ‘\t‘: ‘\\t‘,
                    ‘\n‘: ‘\\n‘,
                    ‘\f‘: ‘\\f‘,
                    ‘\r‘: ‘\\r‘,
                    ‘"‘: ‘\\"‘,
                    ‘\\‘: ‘\\\\‘
                };

            function quote(string) {
                escapable.lastIndex = 0;
                return escapable.test(string) ? ‘"‘ + string.replace(escapable, function(a) {
                    var c = meta[a];
                    return typeof c === ‘string‘ ? c : ‘\\u‘ + (‘0000‘ + a.charCodeAt(0).toString(16)).slice(-4);
                }) + ‘"‘ : ‘"‘ + string + ‘"‘;
            }

            function str(key, holder) {
                var
                    i, // The loop counter.
                    k, // The member key.
                    v, // The member value.
                    length,
                    mind = target,
                    partial,
                    value = holder[key];
                if (value && $.isFunction(value.toJSON)) {
                    value = value.toJSON(key);
                }
                if ($.isFunction(iterator)) {
                    value = iterator.call(holder, key, value);
                }
                switch (typeof value) {
                    case ‘string‘:
                        return quote(value);
                    case ‘number‘:
                        return isFinite(value) ? String(value) : ‘null‘;

                    case ‘boolean‘:
                    case ‘null‘:
                        return String(value);
                    case ‘object‘:
                        if (!value) {
                            return ‘null‘;
                        }
                        target += indent;
                        partial = [];
                        if ($.isArray(value)) {
                            length = value.length;
                            for (i = 0; i < length; i += 1) {
                                partial[i] = str(i, value) || ‘null‘;
                            }
                            v = partial.length === 0 ? ‘[]‘ : target ? ‘[\n‘ + target + partial.join(‘,\n‘ + target) + ‘\n‘ + mind + ‘]‘ : ‘[‘ + partial.join(‘,‘) + ‘]‘;
                            target = mind;
                            return v;
                        }
                        if (iterator && typeof iterator === ‘object‘) {
                            length = iterator.length;
                            for (i = 0; i < length; i += 1) {
                                if (typeof iterator[i] === ‘string‘) {
                                    k = iterator[i];
                                    v = str(k, value);
                                    if (v) {
                                        partial.push(quote(k) + (target ? ‘: ‘ : ‘:‘) + v);
                                    }
                                }
                            }
                        } else {
                            for (k in value) {
                                if (hasOwn.call(value, k)) {
                                    v = str(k, value);
                                    if (v) {
                                        partial.push(quote(k) + (target ? ‘: ‘ : ‘:‘) + v);
                                    }
                                }
                            }
                        }
                        v = partial.length === 0 ? ‘{}‘ : target ? ‘{\n‘ + target + partial.join(‘,\n‘ + target) + ‘\n‘ + mind + ‘}‘ : ‘{‘ + partial.join(‘,‘) + ‘}‘;
                        target = mind;
                        return v;
                }
            }

            if (!$.isFunction(Date.prototype.toJSON)) {
                function f(n) {
                    return n < 10 ? ‘0‘ + n : n;
                }
                Date.prototype.toJSON = function(key) {
                    return isFinite(this.valueOf()) ? this.getUTCFullYear() + ‘-‘ +
                        f(this.getUTCMonth() + 1) + ‘-‘ +
                        f(this.getUTCDate()) + ‘T‘ +
                        f(this.getUTCHours()) + ‘:‘ +
                        f(this.getUTCMinutes()) + ‘:‘ +
                        f(this.getUTCSeconds()) + ‘Z‘ : null;
                };

                String.prototype.toJSON =
                    Number.prototype.toJSON =
                    Boolean.prototype.toJSON = function(key) {
                        return this.valueOf();
                    };
            }
            $.improve(window.JSON = window.JSON || {}, {
                parse: function(text, reviver) {
                    var j, walk = function(holder, key) {
                        var k, v, value = holder[key];
                        if (value && typeof value === ‘object‘) {
                            for (k in value) {
                                if (Object.prototype.hasOwnProperty.call(value, k)) {
                                    v = walk(value, k);
                                    if (v !== undefined) {
                                        value[k] = v;
                                    } else {
                                        delete value[k];
                                    }
                                }
                            }
                        }
                        return reviver.call(holder, key, value);
                    }
                    text = String(text);
                    cx.lastIndex = 0;
                    if (cx.test(text)) {
                        text = text.replace(cx, function(a) {
                            return ‘\\u‘ +
                                (‘0000‘ + a.charCodeAt(0).toString(16)).slice(-4);
                        });
                    }
                    if (/^[\],:{}\s]*$/.test(
                            text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, ‘@‘)
                            .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ‘]‘)
                            .replace(/(?:^|:|,)(?:\s*\[)+/g, ‘‘)
                        )) {
                        j = eval(‘(‘ + text + ‘)‘);
                        return $.isFunction(reviver) ? walk({
                            ‘‘: j
                        }, ‘‘) : j;
                    }
                    $.error(‘JSON.parse‘);
                },
                stringify: function(value, replacer, space) {
                    var i;
                    indent = ‘‘;
                    iterator = ‘‘;
                    if ($.isNumber(space)) {
                        for (i = 0; i < space; i += 1) {
                            indent += ‘ ‘;
                        }
                    } else if ($.isString(space)) {
                        indent = space;
                    }
                    iterator = replacer;
                    if (
                        replacer && !$.isFunction(replacer) &&
                        (typeof replacer !== ‘object‘ || typeof replacer.length !== ‘number‘)
                    ) {
                        $.error(‘JSON.stringify‘);
                    }
                    return str(‘‘, {
                        ‘‘: value
                    });
                }
            });
        })(ToolKit);

        var sortInput, hasDuplicate;
        var documentElement = document.documentElement;
        var rnative = /^[^{]+\{\s*\[native \w/;
        var check = function(tag, callbak) {
            if (arguments.length === 1) {
                callbak = tag;
                tag = "div";
            }
            var elem = document.createElement(tag);
            try {
                return !!callbak(elem);
            } catch (e) {
                return false;
            } finally {
                if (elem.parentNode) {
                    elem.parentNode.removeChild(elem);
                }
                elem = null;
            }
        };
        if (rnative.test(document.getElementsByClassName)) {
            support.getElementsByClassName = check(function(div) {
                div.innerHTML = "<div class=‘a‘></div><div class=‘a i‘></div>";
                div.firstChild.className = "i";
                return div.getElementsByClassName("i").length === 2;
            });
        }
        if (rnative.test(document.querySelectorAll)) {
            support.querySelectorAll = true;
            var rquerySelectorAll = [];
            check(function(div) {
                div.innerHTML = "<select msallowclip=‘‘><option selected=‘‘></option></select>";
                if (div.querySelectorAll("[msallowclip^=‘‘]").length) {
                    rquerySelectorAll.push("[*^$]=" + whitespace + "*(?:‘‘|\"\")");
                }
                if (!div.querySelectorAll("[selected]").length) {
                    rquerySelectorAll.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
                }
                if (!div.querySelectorAll(":checked").length) {
                    rquerySelectorAll.push(":checked");
                }
            });
            check(function(div) {
                var input = document.createElement("input");
                input.setAttribute("type", "hidden");
                input.id = "B";
                div.appendChild(document.createElement("div").appendChild(document.createElement("a")));
                div.appendChild(input).setAttribute("name", "D");
                if (div.querySelectorAll("[name=d]").length || !div.querySelectorAll("[name=D]").length) {
                    rquerySelectorAll.push("name" + whitespace + "*[*^$|!~]?=");
                }
                if (div.querySelectorAll("input[id=‘b‘]").length || !div.querySelectorAll("input[id=‘B‘]").length) {
                    rquerySelectorAll.push("id" + whitespace + "*[*^$|!~]?=");
                }
                if (!div.querySelectorAll(":enabled").length) {
                    rquerySelectorAll.push(":enabled", ":disabled");
                }
                div.querySelectorAll("*,:x");
                rquerySelectorAll.push(",.*:");
            });
            check(function(div) {
                documentElement.appendChild(div).innerHTML = "<a id=‘toolkit‘></a>" +
                    "<select id=‘toolkit-\r\\‘ msallowcapture=‘‘>" +
                    "<option selected=‘‘></option></select>";
                if (div.querySelectorAll("[msallowcapture^=‘‘]").length) {
                    rquerySelectorAll.push("[*^$]=" + whitespace + "*(?:‘‘|\"\")");
                }
                if (!div.querySelectorAll("[selected]").length) {
                    rquerySelectorAll.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
                }
                if (!div.querySelectorAll("[id~=toolkit-]").length) {
                    rquerySelectorAll.push("~=");
                }
                if (!div.querySelectorAll(":checked").length) {
                    rquerySelectorAll.push(":checked");
                }
                if (!div.querySelectorAll("a#toolkit+*").length) {
                    rquerySelectorAll.push(".#.+[+~]");
                }
            });
            support.rquerySelectorAll = !rquerySelectorAll.length || new RegExp(rquerySelectorAll.join("|"));
        }
        if (rnative.test((support.matches = documentElement.matches || documentElement.webkitMatchesSelector || documentElement.mozMatchesSelector || documentElement.oMatchesSelector || documentElement.msMatchesSelector))) {
            support.matchesSelector = true;
            check(function(div) {
                var matchesSelector = [];
                support.disConnectedMatch = support.matches.call(div, "div");
                matches.call(div, "[s!=‘‘]:x");
                matchesSelector.push("!=", extensions);
                support.rmatchesSelector = new RegExp(matchesSelector.join("|"));
            });
        }
        support.getElementById = check(function() {
            document.documentElement.appendChild(div).id = "test";
            if (document.getElementById) {
                return !document.getElementsByName || !document.getElementsByName("test").length;
            }
        });
        support.getElementsByTagName = check(function(div) {
            div.appendChild(document.createComment(""));
            return !div.getElementsByTagName("*").length;
        });
        check("form", function(form) {
            support.enctype = !!form.enctype;
        });
        check("input", function(input) {
            input.type = "checkbox";
            support.checkOn = input.value !== "";
            input.value = "t";
            input.type = "radio";
            support.radioValue = input.value === "t";
        });
        check("select", function(select) {
            var option = select.appendChild(document.createElement("option"));
            select.disabled = true;
            support.optionSelected = option.selected;
            support.optionDisabled = !option.disabled;
        });
        check(function(div) {
            var a, t, style, input;
            div.setAttribute("className", "t"),
                div.innerHTML = "  <link/><table></table><a href=‘/a‘>a</a><input type=‘checkbox‘/><!--<span></span>-->";
            a = (t = div.getElementsByTagName("a")) ? t[0] : null;
            input = (t = div.getElementsByTagName("input")) ? t[0] : {};
            style = a && a.style;
            if (!style) {
                return;
            }
            support.leadingWhitespace = div.firstChild.nodeType === 3;
            support.leadingAnnotation = div.lastChild.nodeType === 8;
            support.tbody = !div.getElementsByTagName("tbody").length;
            support.htmlSerialize = !!div.getElementsByTagName("link").length;
            support.html5Clone = document.createElement("nav").cloneNode(true).outerHTML !== "<:nav></:nav>";
            support.attr = div.className !== "t";
            style.cssText = "float:left;opacity:.5;top:1px";
            support.opacity = style.opacity === "0.5";
            support.cssFloat = !!style.cssFloat;
            support.style = /top/.test(a.getAttribute("style"));
            support.hrefNormalized = a.getAttribute("href") === "/a";
        });
        check(function(div) {
            var
                i,
                len,
                value,
                target,
                style = div.style,
                list = ["boxSizing", "boxShadow", "animation", "transition", "transform", "transformOrigin", "transitionDelay", "filter"];
            checking = function(t) {
                if (t in style) return true;
                target = t.charAt(0).toUpperCase() + t.slice(1);
                for (var i = 0, len = cssfix.length; i < len; i++) {
                    if ((cssfix[i] + target) in style) {
                        return true;
                    }
                }
                return false;
            };
            for (i = 0, len = list.length; i < len; i++) {
                value = list[i];
                support[value] = checking(value)
            }
            for (i in {
                    submit: true,
                    change: true,
                    focusin: true
                }) {
                value = "on" + i;
                support[i] = (value in window);
            }
        });
        check(function(div) {
            div.style.backgroundClip = "content-box";
            div.cloneNode(true).style.backgroundClip = "";
            support.clearCloneStyle = div.style.backgroundClip === "content-box";

            div.innerHTML = "<input type=‘radio‘ checked=‘checked‘ name=‘t‘/>";
            support.checkClone = !!div.cloneNode(true).cloneNode(true).lastChild.checked;

            support.eventClone = false;
            var motheds = function() {
                support.eventClone = true;
            };
            if (div.addEventListener) {
                div.addEventListener("click", motheds, false);
            } else if (div.attachEvent) {
                div.attachEvent("onclick", motheds);
            }
            div.cloneNode(true).click();
        });

        var siblingCheck = function(a, b) {
            var cur = b && a,
                diff = cur && a.nodeType === 1 && b.nodeType === 1 && (~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE);
            if (diff) {
                return diff;
            }
            if (cur) {
                while ((cur = cur.nextSibling)) {
                    if (cur === b) {
                        return -1;
                    }
                }
            }
            return a ? 1 : -1;
        };

        var hasCompare = rnative.test(documentElement.compareDocumentPosition);
        var contains = hasCompare || rnative.test(documentElement.contains) ?
            function(a, b) {
                var adown = a.nodeType === 9 ? a.documentElement : a,
                    bup = b && b.parentNode;
                return a === bup || !!(bup && bup.nodeType === 1 && (
                    adown.contains ?
                    adown.contains(bup) :
                    a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16
                ));
            } :
            function(a, b) {
                if (b) {
                    while ((b = b.parentNode)) {
                        if (b === a) {
                            return true;
                        }
                    }
                }
                return false;
            };

        var sortOrder = hasCompare ?
            function(a, b) {

                if (a === b) {
                    hasDuplicate = true;
                    return 0;
                }
                var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
                if (compare) {
                    return compare;
                }
                compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1;
                if (compare & 1 ||
                    (!support.sortDetached && b.compareDocumentPosition(a) === compare)) {
                    if (a === document || a.ownerDocument === window.document && contains(window.document, a)) {
                        return -1;
                    }
                    if (b === document || b.ownerDocument === window.document && contains(window.document, b)) {
                        return 1;
                    }
                    return sortInput ? (indexOf(sortInput, a) - indexOf(sortInput, b)) : 0;
                }

                return compare & 4 ? -1 : 1;
            } :
            function(a, b) {
                if (a === b) {
                    hasDuplicate = true;
                    return 0;
                }

                var cur,
                    i = 0,
                    aup = a.parentNode,
                    bup = b.parentNode,
                    ap = [a],
                    bp = [b];
                if (!aup || !bup) {
                    return a === document ? -1 :
                        b === document ? 1 :
                        aup ? -1 :
                        bup ? 1 :
                        sortInput ?
                        (indexOf(sortInput, a) - indexOf(sortInput, b)) :
                        0;
                } else if (aup === bup) {
                    return siblingCheck(a, b);
                }
                cur = a;
                while ((cur = cur.parentNode)) {
                    ap.unshift(cur);
                }
                cur = b;
                while ((cur = cur.parentNode)) {
                    bp.unshift(cur);
                }
                while (ap[i] === bp[i]) {
                    i++;
                }
                return i ? siblingCheck(ap[i], bp[i]) : ap[i] === window.document ? -1 : bp[i] === window.document ? 1 : 0;
            };

        var
            init, analysis,
            rmargin = (/^margin/),
            rnumber = /^[+-]?(\d+\.|)(\d+)$/,
            ropacity = /opacity\s*=\s*([^)]*)/,
            rposition = /^(top|right|bottom|left)$/,
            number = "[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)",
            rsplitnumber = new RegExp("^(" + number + ")(.*)$", "i"),
            rrealnumber = new RegExp("^([+-])=(" + number + ")", "i"),
            rpercentnumber = new RegExp("^(" + number + ")(%)$", "i"),
            rstylenumber = new RegExp("^(" + number + ")[a-z%]+$", "i"),
            rnopxnumber = new RegExp("^(" + number + ")(?!px)[a-z%]+$", "i"),
            rfxnumber = new RegExp("^(?:([+-])=|)(" + number + ")([a-z%]*)$", "i"),
            booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
            rbooleans = new RegExp("^(?:" + booleans + ")$", "i"),
            fixNumber = {
                "columnCount": true,
                "fillOpacity": true,
                "flexGrow": true,
                "flexShrink": true,
                "fontWeight": true,
                "lineHeight": true,
                "opacity": true,
                "order": true,
                "orphans": true,
                "windows": true,
                "zIndex": true,
                "zoom": true
            },
            fix = function(o, key) {
                if (key in o) return key;
                var i = 0,
                    fixkey;
                key = key.charAt(0).toUpperCase() + key.slice(1);
                while ((fixkey = cssfix[i++]) && !((fixkey = fixkey + key) in o)) {}
                return ToolKit.fx.props[key] = (fixkey || key);
            };
        if (window.getComputedStyle) {
            init = function(elem, key) {
                var width, minWidth, maxWidth,
                    view = analysis(elem),
                    style = elem && elem.style,
                    value = view && (view.getPropertyValue(key) || view[key]) || style && style[key] || "";
                if (style && rnopxnumber.test(value) && !rmargin.test(key)) {
                    width = style.width;
                    minWidth = style.minWidth;
                    maxWidth = style.maxWidth;
                    style.minWidth = style.maxWidth = style.width = value;

                    value = view.width;

                    style.width = width;
                    style.minWidth = minWidth;
                    style.maxWidth = maxWidth;
                }
                return value && (value + "");
            }
            analysis = function(elem) {
                return elem && elem.ownerDocument && elem.ownerDocument.defaultView.getComputedStyle(elem, null);
            }
        } else {
            init = function(elem, key) {
                var left, rs, rsLeft,
                    view = analysis(elem),
                    style = elem && elem.style,
                    value = view && view[name] || style && style[name] || "";
                if (style && rnopxnumber.test(value) && !rposition.test(name)) {
                    left = style.left;
                    rs = elem.runtimeStyle;
                    rsLeft = rs && rs.left;
                    if (rsLeft) {
                        rs.left = elem.currentStyle.left;
                    }
                    style.left = name === "fontSize" ? "1em" : value;

                    value = style.pixelLeft + "px";

                    style.left = left;
                    if (rsLeft) {
                        rs.left = rsLeft;
                    }
                }
                return (value != null) && ((value + "") || "auto");
            }
            analysis = function(elem) {
                return elem && elem.currentStyle;
            }
        }
        ToolKit.fx = {
            base: init,
            init: function(elem, key, value) {
                if (!elem || !key || !elem.nodeType || elem.nodeType === 3 || elem.nodeType === 8 || elem.nodeType === 9) {
                    return;
                }
                key = ToolKit.camelCase(key);
                var
                    hooks,
                    style = elem.style,
                    fixkey = ToolKit.fx.props[key] || fix(style, key);
                hooks = ToolKit.fx.hooks[fixkey] || ToolKit.fx.hooks[key];
                if (arguments.length === 2) {
                    if (hooks && ("get" in hooks)) {
                        value = hooks.get(elem);
                    }
                    if (value == null) {
                        value = ToolKit.fx.base(elem, key);
                    }
                    if (value === "normal") {
                        value = cssform[key] || value;
                    }
                    return value;
                }
                if (value == null) {
                    if (rbooleans.test(key)) {
                        if (support.input && support.attr || !rdefault.test(key)) {
                            elem[key] = false;
                        } else {
                            elem[ToolKit.camelCase("default-" + name)] = elem[key] = false;
                        }
                    } else {
                        ToolKit.fx.init(elem, key, "");
                    }
                    elem.removeAttribute(key);
                }
                var type = ToolKit.type(value);
                if ((type === "string") && (result = rrealnumber.exec(value))) {
                    type = "number";
                    value = (result[1] + 1) * result[2] + parseFloat(ToolKit.fx.init(elem, key));
                }
                if (value == null || value !== value) {
                    return value;
                }
                if (!fixNumber[key] && ((type === "number") && !rpercentnumber.test(value) || rnumber.test(value))) {
                    value += "px";
                }
                if (!support.clearCloneStyle && value === "" && key.indexOf("background") === 0) {
                    style[key] = "inherit";
                }
                if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value)) != null) {
                    try {
                        style[key] = value;
                    } catch (e) {}
                }
            },
            hooks: {
                opacity: support.opacity ? {
                    get: function(elem) {
                        var value = init(elem, "opacity");
                        return value === "" ? "1" : value;
                    }
                } : {
                    get: function(elem) {
                        return ropacity.test((elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ? (0.01 * parseFloat(RegExp.$1)) + "" : "1";
                    },
                    set: function(elem, value) {
                        var style = elem.style,
                            currentStyle = elem.currentStyle,
                            opacity = ToolKit.isNumber(value) ? "alpha(opacity=" + (value < 1 ? value * 100 : value) + ")" : "",
                            filter = currentStyle && currentStyle.filter || style.filter || "";
                        style.zoom = 1;
                        if ((value === "") &&
                            ToolKit.trim(filter.replace(ralpha, "")) === "" &&
                            style.removeAttribute) {
                            style.removeAttribute("filter");
                            if (value === "" || currentStyle && !currentStyle.filter) {
                                return;
                            }
                        }
                        style.filter = ralpha.test(filter) ? filter.replace(ralpha, opacity) : filter + " " + opacity;
                    }
                }
            },
            props: {
                "float": support.cssFloat ? "cssFloat" : "styleFloat"
            }
        };

        var
            rclickable = /^(?:a|area)$/i,
            rdefault = /^(?:checked|selected)$/i,
            rfocusable = /^(?:input|select|textarea|button|object)$/i,
            hooks = {
                _default: {
                    get: function(elem, key) {
                        if (elem && elem.getAttribute) {
                            return elem.getAttribute(key);
                        }
                        return null;
                    },
                    set: function(elem, value, key) {
                        if (elem && elem.setAttribute) {
                            elem.setAttribute(key, value);
                        }
                        return value;
                    }
                }
            };
        ToolKit.ft = {
            init: function(elem, key, value) {
                if (!elem || !key || !elem.nodeType || elem.nodeType === 2 || elem.nodeType === 3 || elem.nodeType === 8) {
                    return null;
                }
                if (!support.attr) {
                    key = ToolKit.ft.props[key] || key;
                }
                var val, hooks = ToolKit.ft.hooks[key];
                if (arguments.length == 2) {
                    if (!hooks || !("get" in hooks) || (val = hooks.get()) == null) {
                        val = ToolKit.ft.hooks._default.get(elem, key);
                    }
                    if (!val && support.attr && (key in ToolKit.ft.props)) {
                        val = ToolKit.ft.hooks._default.get(elem, ToolKit.ft.props[key]);
                    }
                    return val;
                }
                if (hooks && "set" in hooks && (val = hooks.set(elem, value + "", key)) !== undefined) {
                    return val;
                } else {
                    ToolKit.ft.hooks._default.set(elem, value + "", key);
                    return value;
                }
            },
            hooks: hooks,
            props: {
                "for": "htmlFor",
                "class": "className"
            }
        };
        ToolKit.extend(hooks, {
            tabIndex: {
                get: function(elem) {
                    var val = hooks._default.get(elem, "tabindex");
                    return val ? parseInt(val, 10) : rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href ? 0 : -1;
                }
            },
            type: {
                set: function(elem, value, key) {
                    if (!support.radioValue && value === "radio" && ToolKit.nodeName(elem, "input")) {
                        var val = elem.value;
                        elem.setAttribute("type", value);
                        if (val) {
                            elem.value = val;
                        }
                        return value;
                    }
                }
            },
            option: {
                get: function(elem) {
                    var val = ToolKit.attr(elem, "value");
                    return val != null ? val : ToolKit.trim(ToolKit.text(elem));
                }
            },
            select: {
                get: function(elem) {
                    var
                        value, option,
                        options = elem.options,
                        index = elem.selectedIndex,
                        only = elem.type === "select-one" || index < 0,
                        values = only ? null : [],
                        max = only ? index + 1 : options.length,
                        i = index < 0 ? max : only ? index : 0;
                    for (; i < max; i++) {
                        option = options[i];
                        if ((option.selected || i === index) &&
                            (support.optionDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
                            (!option.parentNode.disabled || !ToolKit.nodeName(option.parentNode, "optgroup"))) {
                            value = hooks.option.get(option);
                            if (only) {
                                return value;
                            }
                            values.push(value);
                        }
                    }
                    return values;
                },
                set: function(elem, value) {
                    var
                        optionSet, option,
                        options = elem.options,
                        values = concat.apply([], value),
                        i = options.length;
                    while (i--) {
                        option = options[i];
                        if (ToolKit.inArray(hooks.option.get(option), values) >= 0) {
                            try {
                                option.selected = optionSet = true;
                            } catch (_) {
                                option.scrollHeight;
                            }
                        } else {
                            option.selected = false;
                        }
                    }
                    if (!optionSet) {
                        elem.selectedIndex = -1;
                    }
                    return options;
                }
            }
        });
        ToolKit.each(["radio", "checkbox"], function() {
            hooks[this] = {
                set: function(elem, value) {
                    if (ToolKit.isArray(value)) {
                        return (elem.checked = ToolKit.inArray(ToolKit(elem).val(), value) >= 0);
                    }
                }
            };
            if (!support.checkOn) {
                hooks[this].get = function() {
                    return elem.getAttribute("value") === null ? "on" : elem.value;
                };
            }
        });
        ToolKit.each(booleans.split("|"), function(_, key) {
            hooks[key] = {
                get: function(elem) {
                    return elem[key] === true || elem.getAttribute(key);
                },
                set: function(elem, value) {
                    if (support.input && support.attr || !rdefault.test(key)) {
                        hooks._default.set(elem, value, key);
                    } else {
                        elem[ToolKit.camelCase("default-" + key)] = elem[key] = true;
                    }
                    return value;
                }
            }
        });
        ToolKit.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function() {
            ToolKit.ft.props[this.toLowerCase()] = this;
        });
        if (!support.attr || !support.input) {
            hooks["value"] = {
                get: function(elem) {
                    if (elem.nodeName.toLowerCase() === "input") {
                        return elem.defaultValue;
                    }
                },
                set: function(elem, value) {
                    if (elem.nodeName.toLowerCase() === "input") {
                        return elem.defaultValue = value;
                    } else {
                        return hooks._default.set(elem, value, "value");
                    }
                }
            };
        }
        if (!support.hrefNormalized) {
            ToolKit.each(["type", "height", "width"], function(_, key) {
                hooks[key] = {
                    get: function(elem) {
                        var val = elem.getAttribute && elem.getAttribute(key, key === "type" ? 1 : 2);
                        if (!val && !!(val = elem.getAttributeNode(key))) {
                            val = val.specified ? val.value : null;
                        }
                        return val;
                    }
                };
            });
            ToolKit.each(["href", "src"], function(_, key) {
                hooks[key] = {
                    get: function(elem) {
                        return elem.getAttribute(key, 4);
                    }
                };
            });
        }
        if (!support.enctype) {
            ToolKit.ft.props.enctype = "encoding";
        }
        if (!support.attr) {
            ToolKit.extend(hooks, {
                button: {
                    get: function(elem, key) {
                        var ret = elem.getAttributeNode(key);
                        if (ret && ret.specified) {
                            return ret.value;
                        }
                    }
                },
                contenteditable: {
                    set: function(elem, value, key) {
                        hooks._default.set(elem, value === "" ? false : value, key);
                    }
                }
            });
            ToolKit.each(["width", "height"], function(_, key) {
                hooks[key] = {
                    set: function(elem, value) {
                        if (value === "") {
                            elem.setAttribute(key, "auto");
                            return value;
                        }
                    }
                };
            });
        }
        if (!support.style) {
            hooks.style = {
                get: function(elem) {
                    return elem.style.cssText;
                },
                set: function(elem, value) {
                    return (elem.style.cssText = value);
                }
            };
        }
        if (!support.optionSelected) {
            hooks.selected = {
                get: function(elem) {
                    var parent = elem.parentNode;
                    if (parent) {
                        parent.selectedIndex;
                        if (parent.parentNode) {
                            parent.parentNode.selectedIndex;
                        }
                    }
                    return null;
                }
            };
        }

        ToolKit.extend(ToolKit, {
            dir: function(elem, dir, all) {
                elem = (elem || {})[dir];
                if (!all) {
                    while (elem && (elem.nodeType < 6) && (elem.nodeType !== 1)) {
                        elem = elem[dir];
                    }
                    return elem;
                }
                var list = [];
                while (elem && (elem.nodeType < 6)) {
                    if (elem.nodeType === 1) {
                        list.push(elem);
                    }
                    elem = elem[dir];
                }
                return list;
            },
            sibling: function(elem, dir, all) {
                elem = elem || {};
                if (dir === "firstChild" || dir === "lastChild") {
                    var o = {};
                    elem = elem[dir];
                    dir = dir === "firstChild" ? "nextSibling" : "previousSibling";
                    o[dir] = elem;
                    elem = o;
                }
                return ToolKit.dir(elem, dir, all);
            }
        });

        var
            tokenCache = {},
            classCache = {},
            compileCache = {},
            rsibling = /[+~]/,
            rheader = /^h\d$/i,
            rinputs = /^(?:input|select|textarea|button)$/i,
            rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
            characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
            identifier = "(?:\\\\.|[\\w#-]|[^\\x00-\\xa0])+",
            rtrimV2 = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"),
            attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace + "*([*^$|!~]?=)" + whitespace +
            "*(?:‘((?:\\\\.|[^\\\\‘])*)‘|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]",
            extra = ":(" + characterEncoding + ")(?:\\(((‘((?:\\\\.|[^\\\\‘])*)‘|\"((?:\\\\.|[^\\\\\"])*)\")|" +
            "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + ".*" + ")\\)|)",
            rextra = new RegExp(extra),
            ridentifier = new RegExp("^" + identifier + "$"),
            rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
            runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"),
            funescape = function(_, escaped, escapedWhitespace) {
                var high = "0x" + escaped - 0x10000;
                return high !== high || escapedWhitespace ?
                    escaped : high < 0 ?
                    String.fromCharCode(high + 0x10000) :
                    String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
            };
        support.sortStable = ["kit"].sort(sortOrder).join("") === "kit";
        support.detectDuplicates = !!hasDuplicate;

        function MakeFunction(callbak) {
            return function() {
                return callbak;
            }
        }

        ToolKit.fs = {
            match: {
                "ID": new RegExp("^#(" + characterEncoding + ")"),
                "CLASS": new RegExp("^\\.(" + characterEncoding + ")"),
                "TAG": new RegExp("^((?:\\\\.|[\\w*-]|[^\\x00-\\xa0])+)"),
                "ATTR": new RegExp("^" + attributes),
                "BOOLEAN": rbooleans,
                "BLANK": rcombinators,
                "CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace +
                    "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
                "CONTEXT": new RegExp("^:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
                    whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i"),
                "EXTRA": new RegExp("^" + extra)
            },
            blank: {
                " ": function() {
                    return function(elem) {
                        return ToolKit.filterTag(elem, "*");
                    }
                },
                ">": function() {
                    return function(elem) {
                        return ToolKit.sibling(elem, "firstChild", true);
                    }
                },
                "~": function() {
                    return function(elem) {
                        return ToolKit.dir(elem, "nextSibling", true);
                    }
                },
                "+": function() {
                    return function(elem) {
                        elem = ToolKit.dir(elem, "nextSibling");
                        return elem && elem.parentNode ? [elem] : [];
                    }
                }
            },
            find: {
                "ID": support.getElementById ? function(id, context) {
                    if (context.getElementById) {
                        var elem = context.getElementById(id);
                        return elem && elem.parentNode ? [elem] : [];
                    }
                } : function(id, context) {
                    var i = 0,
                        elem, filter = ToolKit.fs.filter["ID"](id),
                        list = ToolKit.fs.find["TAG"]("*", context);
                    while ((elem = list[i++])) {
                        if (filter(elem)) {
                            return [elem];
                        }
                    }
                },
                "TAG": support.getElementsByTagName ?
                    function(tag, context) {
                        if (context.getElementsByTagName) {
                            return context.getElementsByTagName(tag);
                        }
                    } : function(tag, context) {
                        var elem,
                            i = 0,
                            tmp = [],
                            results = context.getElementsByTagName(tag);
                        if (tag === "*") {
                            while ((elem = results[i++])) {
                                if (elem.nodeType === 1) {
                                    tmp.push(elem);
                                }
                            }
                            return tmp;
                        }
                        return results;
                    },
                "CLASS": support.getElementsByClassName ? function(className, context) {
                    if (context.getElementsByClassName) {
                        return context.getElementsByClassName(className);
                    }
                } : function(className, context) {
                    var i = 0,
                        elem, results = [],
                        filter = ToolKit.fs.filter["CLASS"](className),
                        list = ToolKit.fs.find["TAG"]("*", context);
                    while ((elem = list[i++])) {
                        if (filter(elem)) {
                            results.push(elem);
                        }
                    }
                    return results;
                }
            },
            filter: {
                "ID": function(id) {
                    var attrId = id.replace(runescape, funescape);
                    return function(elem) {
                        return elem.getAttribute("id") === attrId;
                    };
                },
                "TAG": function(tag) {
                    var nodeName = tag.replace(runescape, funescape).toLowerCase();
                    return tag === "*" ?
                        function() {
                            return true;
                        } :
                        function(elem) {
                            return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
                        };
                },
                "CLASS": function(className) {
                    var pattern = classCache[className];
                    return pattern ||
                        (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) &&
                        (classCache[className] = function(elem) {
                            return pattern.test(typeof elem.className === "string" && elem.className || elem.getAttribute && elem.getAttribute("class") || "");
                        });
                },

                "ATTR": function(name, operator, check) {
                    return function(elem) {
                        var result = ToolKit.attr(elem, name);

                        if (result == null) {
                            return operator === "!=";
                        }
                        if (!operator) {
                            return true;
                        }

                        result += "";

                        return operator === "=" ? result === check :
                            operator === "!=" ? result !== check :
                            operator === "^=" ? check && result.indexOf(check) === 0 :
                            operator === "*=" ? check && result.indexOf(check) > -1 :
                            operator === "$=" ? check && result.slice(-check.length) === check :
                            operator === "~=" ? (" " + result + " ").indexOf(check) > -1 :
                            operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" :
                            false;
                    };
                },
                "BLANK": function(type) {
                    return ToolKit.fr.blank[type]();
                },
                "CHILD": function(type, what, arg, first, last) {
                    if (!(type in ToolKit.fs.child)) {
                        ToolKit.syntaxError("Sorry! Not yet defined types:" + match.type);
                    }
                    return ToolKit.fs.child[type](what, first, last);
                },
                "CONTEXT": function(type, i) {
                    if (!(type in ToolKit.fs.context)) {
                        ToolKit.syntaxError("Sorry! Not yet defined types:" + match.type);
                    }
                    return ToolKit.fs.context[type](this, i);
                },
                "EXTRA": function(type, args) {
                    if (!(type in ToolKit.fs.extra)) {
                        ToolKit.syntaxError("Sorry! Not yet defined types:" + match.type);
                    }
                    return ToolKit.fs.extra[type](args);
                }
            },
            filters: {
                "ATTR": function(match) {
                    match[1] = match[1].replace(runescape, funescape);
                    match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);

                    if (match[2] === "~=") {
                        match[3] = " " + match[3] + " ";
                    }
                    return match.slice(0, 4);
                },
                "CHILD": function(match) {
                    match[1] = match[1].toLowerCase();

                    if (match[1].slice(0, 3) === "nth") {
                        if (!match[3]) {
                            ToolKit.syntaxError(match[0]);
                        }
                        match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
                        match[5] = +((match[7] + match[8]) || match[3] === "odd");
                        if (match[5] < 0) {
                            match[5] = match[5] % match[4];
                        }
                    } else if (match[3]) {
                        ToolKit.syntaxError(match[0]);
                    }
                    return match;
                },
                "CONTEXT": function(match) {
                    match[1] = match[1].toLowerCase();
                    if (match[1] === "nth" || match[1] === "eq" || match[1] === "gt" || match[1] === "lt") {
                        if (!match[2]) {
                            ToolKit.syntaxError(match[0]);
                        }
                        match[2] = +match[2];
                    } else if (match[2]) {
                        ToolKit.syntaxError(match[0]);
                    }
                    return match;
                },
                "EXTRA": function(match) {
                    var excess,
                        string = !match[6] && match[2];
                    if (ToolKit.fs.match["CHILD"].test(match[0]) || ToolKit.fs.match["CONTEXT"].test(match[0])) {
                        return null;
                    }
                    if (match[3]) {
                        match[2] = match[4] || match[5] || "";
                    } else if (string && rextra.test(string) &&
                        (excess = ToolKit.fs.tokenize(string, true)) &&
                        (excess = string.indexOf(")", string.length - excess) - string.length)) {
                        match[0] = match[0].slice(0, excess);
                        match[2] = string.slice(0, excess);
                    }
                    return match.slice(0, 3);
                }
            },
            child: {
                first: function(what) {
                    return function(elem) {
                        var
                            tag = elem.nodeName.toLowerCase(),
                            node = elem.parentNode.firstChild;
                        for (; node; node = node.nextSibling) {
                            if (what === "of-type" ? node.nodeName.toLowerCase() === tag : node.nodeType === 1) {
                                return elem == node;
                            }
                        }
                        return false;
                    }
                },
                last: function(what) {
                    return function(elem) {
                        var
                            tag = elem.nodeName.toLowerCase(),
                            node = elem.parentNode.firstChild;
                        for (; node; node = node.previousSibling) {
                            if (what === "of-type" ? node.nodeName.toLowerCase() === tag : node.nodeType === 1) {
                                return elem == node;
                            }
                        }
                        return null;
                    }
                },
                only: function(what) {
                    return function(elem) {
                        var list = [];
                        var
                            tag = elem.nodeName.toLowerCase(),
                            node = elem.parentNode.firstChild;
                        for (; node; node = node.nextSibling) {
                            if (what === "of-type" ? node.nodeName.toLowerCase() === tag : node.nodeType === 1) {
                                return list.push(node);
                            }
                            if (list.length > 1) {
                                break;
                            }
                        }
                        return list.length === 1;
                    }
                },
                nth: function(what, first, last) {
                    return function(elem) {
                        var
                            list = [],
                            tag = elem.nodeName.toLowerCase(),
                            node = elem.parentNode.firstChild;
                        for (; node; node = node.nextSibling) {
                            if (what === "of-type" ? node.nodeName.toLowerCase() === tag : node.nodeType === 1) {
                                return list.push(node);
                            }
                        }
                        var i = 0,
                            index, len = list.length;
                        if (first > 0) {
                            for (;
                                (index = (i * first + last - 1)) < len; i++) {
                                if (index in list && list[index] == elem) {
                                    return true;
                                }
                            }
                        } else {
                            index = last - 1;
                            return (index in list) && list[index] == elem;
                        }
                        return false;
                    };
                },
                "nth-last": function(what, first, last) {
                    return function() {
                        var
                            list = [],
                            tag = elem.nodeName.toLowerCase(),
                            node = elem.parentNode.firstChild;
                        for (; node; node = node.nextSibling) {
                            if (what === "of-type" ? node.nodeName.toLowerCase() === tag : node.nodeType === 1) {
                                return list.push(node);
                            }
                        }
                        var i, index;
                        if (first > 0) {
                            for (i = Math.ceil((list.length - last) / first);
                                (index = (i * first + last - 1)) >= 0; i--) {
                                if (index in list && list[index] == elem) {
                                    return true;
                                }
                            }
                        } else {
                            index = list.length - last;
                            return index in list && list[index] == elem;
                        }
                        return false;
                    }
                }
            },
            context: {
                first: function(list) {
                    return list.length > 0 ? [list[0]] : [];
                },
                last: function(list) {
                    return list.length > 0 ? [list[list.length - 1]] : [];
                },
                even: function(list) {
                    var
                        i = 0,
                        result = [],
                        len = list.length;
                    for (; i < len; i += 2) {
                        if (i in list) {
                            result.push(list[i]);
                        }
                    }
                    return list;
                },
                odd: function(list) {
                    var
                        i = 1,
                        result = [],
                        len = list.length;
                    for (; i < len; i += 2) {
                        if (i in list) {
                            result.push(list[i]);
                        }
                    }
                    return list;
                },
                nth: function(list, i) {
                    i = i + (i < 0 ? list.length : 0);
                    return list.length > i ? [list[i]] : [];
                },
                eq: function(list, i) {
                    i = i + (i < 0 ? list.length : 0);
                    return list.length > i ? [list[i]] : [];
                },
                gt: function(list, i) {
                    var result = [];
                    for (; i < list.length; i++) {
                        result.push(list[i]);
                    }
                    return result;
                },
                lt: function() {
                    var result = [];
                    i = Math.min(i, list.length);
                    for (; i >= 0; i--) {
                        result.push(list[i]);
                    }
                    return result;
                }
            },
            extra: {
                not: function(selector) {
                    var callbak = ToolKit.fs.compile(selector.replace(rtrimV2, "$1"));
                    return function(elem) {
                        return !callbak(elem);
                    }
                },
                has: function(selector) {
                    return function(elem) {
                        return ToolKit(selector, elem).length > 0;
                    }
                },
                contains: function(text) {
                    return function(elem) {
                        return (elem.textContent || elem.innerText || ToolKit.text(elem)).indexOf(text) > -1
                    }
                },
                lang: function(lang) {
                    if (!ridentifier.test(lang || "")) {
                        ToolKit.syntaxError("unsupported lang: " + lang);
                    }
                    lang = lang.replace(runescape, funescape).toLowerCase();
                    return function(elem) {
                        var langs;
                        do {
                            if (!!(langs = elem.lang)) {
                                langs = langs.toLowerCase();
                                return langs === lang || langs.indexOf(lang + "-") === 0;
                            }
                        }
                        while ((elem = elem.parentNode) && elem.nodeType === 1);
                    }
                },
                target: MakeFunction(function(elem) {
                    var hash = window.location && window.location.hash;
                    return hash && hash.slice(1) === elem.id;
                }),
                root: MakeFunction(function(elem) {
                    return elem === document.documentElement;
                }),
                focus: MakeFunction(function(elem) {
                    return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
                }),
                enabled: MakeFunction(function(elem) {
                    return elem.disabled === false;
                }),
                disabled: MakeFunction(function(elem) {
                    return elem.disabled === true;
                }),
                checked: MakeFunction(function(elem) {
                    var nodeName = elem.nodeName.toLowerCase();
                    return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
                }),
                selected: MakeFunction(function(elem) {
                    if (elem.parentNode) {
                        elem.parentNode.selectedIndex;
                    }
                    return elem.selected === true;
                }),
                empty: MakeFunction(function(elem) {
                    for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
                        if (elem.nodeType < 6) {
                            return false;
                        }
                    }
                    return true;
                }),
                parent: MakeFunction(function(elem) {
                    for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
                        if (elem.nodeType < 6) {
                            return true;
                        }
                    }
                    return false;
                }),
                header: MakeFunction(function(elem) {
                    return rheader.test(elem.nodeName);
                }),
                input: MakeFunction(function(elem) {
                    return rinputs.test(elem.nodeName);
                }),
                button: MakeFunction(function(elem) {
                    var name = elem.nodeName.toLowerCase();
                    return name === "button" || name === "input" && elem.type === "button";
                }),
                text: MakeFunction(function(elem) {
                    var attr;
                    return elem.nodeName.toLowerCase() === "input" &&
                        elem.type === "text" && ((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
                })
            }
        };
        ToolKit.each(["radio", "checkbox", "file", "password", "image"], function(_, type) {
            ToolKit.fs.extra[type] = MakeFunction(function(elem) {
                var name = elem.nodeName.toLowerCase();
                return name === "input" && elem.type === type;
            });
        });
        ToolKit.each(["submit", "reset"], function(_, type) {
            ToolKit.fs.extra[type] = MakeFunction(function(elem) {
                var name = elem.nodeName.toLowerCase();
                return (name === "input" || name === "button") && elem.type === type;
            });
        });

        function PrecisionFilter(token, result, i) {
            var r, match, filter, len = token.length;
            for (; i < len; i++) {
                match = token[i];
                filter = ToolKit.fs.filter[match.type].apply(result, match.matches);
                if (ToolKit.isFunction(filter)) {
                    result = ToolKit.map(result, function(elem) {
                        if (!!(r = filter(elem))) {
                            return r === true ? elem : r;
                        }
                    });
                } else {
                    result = filter;
                }
                if (!result || !result.length) {
                    break;
                }
            }
            return result;
        }

        ToolKit.extend(ToolKit.fs, {
                base: function(selector, context, results, isFilter) {
                    var tokens = ToolKit.fs.tokenize(selector);
                    var match, token, result, i = 0,
                        list = [],
                        len = tokens.length;
                    for (; i < len; i++) {
                        token = tokens[i];
                        if (isFilter) {
                            result = [context];
                        } else {
                            if (token[0].type in ToolKit.fs.find) {
                                match = token[0];
                                result = ToolKit.fs.find[match.type](match.matches[0], context);
                            } else {
                                result = ToolKit.fs.find["TAG"]("*", context);
                            }
                        }
                        ToolKit.merge(list, PrecisionFilter(token, result, match ? 1 : 0));
                        if (isFilter) {
                            return list.length > 0;
                        }
                        push.apply(results = results || [], list);
                        return results.length > 0 ? ToolKit.fs.uniqueSort(results) : results;
                    },
                    init: function(selector, context, results) {
                            results = results || [];
                            context = context || document;
                            if (!selector || typeof selector !== "string") {
                                return results;
                            }
                            var elem, match, nodeType = context.nodeType;
                            if (!(nodeType === 1 || nodeType === 9)) {
                                return results;
                            }
                            if (!!(match = rquickExpr.exec(selector))) {
                                if (match[1]) {
                                    if (nodeType === 9) {
                                        elem = context.getElementById(match[1]);
                                        if (elem && elem.parentNode && elem.id === match[1]) {
                                            results.push(elem);
                                        }
                                        return results;
                                    } else {
                                        if (context.ownerDocument && (elem = context.ownerDocument.getElementById(match[1])) &&
                                            contains(context, elem) && elem.id === match[1]) {
                                            results.push(elem);
                                            return results;
                                        }
                                    }
                                } else if (match[2]) {
                                    push.apply(results, context.getElementsByTagName(match[2]));
                                    return results;
                                } else if (match[3] && support.getElementsByClassName && context.getElementsByClassName) {
                                    push.apply(results, context.getElementsByClassName(match[3]));
                                    return results;
                                }
                            }
                            if (support.querySelectorAll && (support.rquerySelectorAll || !support.rquerySelectorAll.test(selector))) {
                                var org = true,
                                    tik = "tik",
                                    newSelector;
                                if (nodeType === 1 && context.nodeName.toLowerCase() !== "object") {
                                    groups = ToolKit.fs.tokenize(selector);

                                    if (!!(org = context.getAttribute("id"))) {
                                        tik = org.replace(rescape, "\\$&");
                                    } else {
                                        context.setAttribute("id", tik);
                                    }
                                    tik = "[id=‘" + tik + "‘] ";

                                    i = groups.length;
                                    while (i--) {
                                        groups[i] = tik + ToolKit.fs.toSelector(groups[i]);
                                    }
                                    newSelector = groups.join(",");
                                }
                                if (newSelector || nodeType === 9) {
                                    try {
                                        push.apply(results,
                                            context.querySelectorAll(newSelector || selector)
                                        );
                                        return results;
                                    } catch (_) {} finally {
                                        if (!org) {
                                            context.removeAttribute("id");
                                        }
                                    }
                                }
                            }
                            return ToolKit.fs.base(selector, context, results);
                        },
                        compile: function(selector, match) {
                            var cache = compileCache[selector];
                            if (!cache) {
                                match = match || ToolKit.fs.tokenize(selector);
                                if (match.length !== 1 || (match[0].length != null || (match = match[0]).length !== 1)) {
                                    ToolKit.syntaxError("The selector definition is wrong!");
                                }
                                if (match.type === "CONTEXT" || match.type === "BLANK") {
                                    ToolKit.syntaxError("The selector definition is wrong! Types cannot be context or blank!");
                                }
                                if (!(match.type in ToolKit.fs.filter)) {
                                    ToolKit.syntaxError("Sorry! Not yet defined types:" + match.type);
                                }
                                cache = ToolKit.fs.filter[match.type].apply(null, match.matches);
                                cache.selector = selector;
                                compileCache[selector] = cache;
                            }
                            return cache;
                        },
                        tokenize: function(selector, parseOnly) {
                            var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector];
                            if (cached) {
                                return parseOnly ? 0 : cached.slice(0);
                            }
                            groups = [];
                            soFar = selector;
                            while (soFar) {
                                if (!matched || (match = rcomma.exec(soFar))) {
                                    if (match) {
                                        soFar = soFar.slice(match[0].length) || soFar;
                                    }
                                    groups.push((tokens = []));
                                }
                                matched = false;
                                if ((match = rcombinators.exec(soFar))) {
                                    matched = match.shift();
                                    tokens.push({
                                        value: matched,
                                        type: match[0].replace(rtrimV2, " ")
                                    });
                                    soFar = soFar.slice(matched.length);
                                }
                                for (type in ToolKit.fs.filter) {
                                    if ((match = ToolKit.fs.match[type].exec(soFar)) && (!ToolKit.fs.filters[type] || (match = ToolKit.fs.filters[type](match)))) {
                                        matched = match.shift();
                                        tokens.push({
                                            value: matched,
                                            type: type,
                                            matches: match
                                        });
                                        soFar = soFar.slice(matched.length);
                                    }
                                }
                                if (!matched) {
                                    break;
                                }
                            }
                            return parseOnly ? soFar.length : soFar ? ToolKit.syntaxError(selector) : (tokenCache[selector] = groups).slice(0);
                        },
                        toSelector: function(tokens) {
                            var
                                i = 0,
                                len = tokens.length,
                                selector = "";
                            for (; i < len; i++) {
                                selector += tokens[i].value;
                            }
                            return selector;
                        },
                        uniqueSort: function(results) {
                            var
                                elem,
                                list = [],
                                i = 0,
                                index = 0;
                            hasDuplicate = !support.detectDuplicates;
                            sortInput = !support.sortStable && results.slice(0);
                            results.sort(sortOrder);
                            if (hasDuplicate) {
                                while ((elem = results[i++])) {
                                    if (elem === results[i]) {
                                        index = list.push(i);
                                    }
                                }
                                while (index--) {
                                    results.splice(list[index], 1);
                                }
                            }
                            sortInput = null;
                            return results;
                        },
                        matchesSelector: function(selector, context) {
                            var match;
                            selector = selector.replace(rattributeQuotes, "=‘$1‘]");
                            if (
                                support.matchesSelector &&
                                (!support.rmatchesSelector || support.rmatchesSelector.test(selector)) &&
                                (!support.rquerySelectorAll || !support.rquerySelectorAll.test(selector))
                            ) {
                                try {
                                    var result = support.matches.call(context, selector);
                                    if (result || support.disconnectedMatch || context.document && context.document.nodeType !== 11) {
                                        return result;
                                    }
                                } catch (e) {}
                            }
                            return ToolKit.fs.base(selector, context, null, true);
                        }
                });

            var
                guid = 0,
                tookit = 0,
                rformElems = /^(?:input|select|textarea)$/i,
                rkeyEvent = /^key/,
                rmouseEvent = /^(?:mouse|pointer|contextmenu)|click/,
                rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
                rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;

            function returnTrue() {
                return true;
            }

            function returnFalse() {
                return false;
            }

            function deleteFn(o, key) {
                try {
                    delete o[key];
                } catch (_) {
                    if (o && key) {
                        o[key] = undefined;
                    }
                }
            }
            ToolKit.event = {
                set: function(elem, type, data) {
                    if (!ToolKit.event.support(elem)) {
                        return null;
                    }
                    var chic, handlers, events, handle, cache = ToolKit.event.get(elem);
                    if (!(events = cache["events"])) {
                        events = cache["events"] = {};
                    }
                    if (!(handle = cache.handle)) {
                        handle = cache.handle = function(e) {
                            if (ToolKit && (!e || ToolKit.event.triggered !== e.type)) {
                                return ToolKit.event.handle.apply(handle.elem, arguments);
                            }
                        };
                        handle.elem = elem;
                    }
                    chic = ToolKit.event.chic[type] || {};
                    if (chic.type) {
                        type = chic.type;
                        chic = ToolKit.event.chic[type] || {};
                    }
                    data = ToolKit.extend(data, {
                        chic: type
                    });
                    if (!(handlers = events[type])) {
                        handlers = events[type] = [];
                        if (!chic.setup || chic.setup.call(elem, data, handle) === false) {
                            ToolKit.addEvent(elem, type, handle);
                        }
                    }
                    if (chic.add) {
                        chic.add.call(elem, data);
                    }
                    handlers.push(data);
                    ToolKit.event.global[type] = true;
                    elem = null;
                },
                get: function(elem, type) {
                    if (!ToolKit.event.support(elem)) {
                        return null;
                    }
                    var
                        kit = elem[ToolKit.kit] = elem[ToolKit.kit] || ++tookit,
                        cache = ToolKit.event.cache[kit] = ToolKit.event.cache[kit] || {};
                    if (!type || type === "*") {
                        return cache;
                    }
                    cache["events"] = cache["events"] || {};
                    if (type === "events" || type === "handle") {
                        return cache[type];
                    }
                    return cache["events"][type];
                },
                has: function(elem, type) {
                    if (!ToolKit.event.support(elem)) {
                        return false;
                    }
                    var
                        kit = elem[ToolKit.kit],
                        cache = ToolKit.event.cache[kit];
                    if (!type || !cache || type === "*") {
                        return !!cache;
                    }
                    if (type === "events" || type === "handle" || !cache["events"]) {
                        return !!cache[type];
                    }
                    return !!cache["events"][type];
                },
                cache: {},
                global: {},
                exclude: {
                    "applet": true,
                    "embed": true,
                    "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
                },
                support: function(elem) {
                    var
                        nodeType = +elem.nodeType || 1,
                        noData = ToolKit.event.exclude[(elem.nodeName + "").toLowerCase()];
                    return nodeType !== 1 && nodeType !== 9 ? false : !noData || noData !== true && elem.getAttribute("classid") === noData;
                },
                add: function(elem, type, handler, data) {
                    if (!ToolKit.event.support(elem)) {
                        return null;
                    }
                    handler.guid = handler.guid || ++guid;
                    ToolKit.event.set(elem, type, {
                        data: data,
                        type: type,
                        handler: handler,
                        guid: handler.guid
                    });
                },
                remove: function(elem, type, handler) {
                    var events, cache = ToolKit.event.get(elem);
                    if (!cache || !(events = cache["events"])) {
                        return;
                    }
                    if (!type || type === "*") {
                        return ToolKit.each(events, function(key) {
                            ToolKit.event.remove(elem, key, handler);
                        });
                    }
                    var i = 0,
                        data, handlers, orgType = type,
                        chic = ToolKit.event.chic[type] || {};
                    if (chic.type) {
                        type = chic.type;
                        chic = ToolKit.event.chic[type] || {};
                    }
                    if (!(handlers = events[type])) {
                        return;
                    }
                    while (!!(data = handlers[i++])) {
                        if ((orgType == data.type) && (!handler || handler.guid == data.guid)) {
                            handlers.splice(i, 1);
                            if (chic.remove) {
                                chic.remove.call(elem, data);
                            }
                        }
                    }
                    if (!handlers.length && (!chic.teardown || chic.teardown.call(elem, cache.handle) === false)) {
                        ToolKit.removeEvent(elem, type, cache.handle);
                        deleteFn(events, type);
                        if (ToolKit.isEmptyObject(events)) {
                            deleteFn(cache, "handle");
                            deleteFn(cache, "events");
                        }
                    }
                },
                trigger: function(event, data, elem, onlyHandlers) {
                    var handle, ontype, cur,
                        bubbleType, chic, tmp, i,
                        eventPath = [elem || document],
                        type = hasOwn.call(event, "type") ? event.type : event;

                    cur = tmp = elem = elem || document;
                    if (elem.nodeType === 3 || elem.nodeType === 8) {
                        return;
                    }
                    if (rfocusMorph.test(type + ToolKit.event.triggered)) {
                        return;
                    }
                    ontype = type.indexOf(":") < 0 && "on" + type;
                    event = event[ToolKit.kit] ?
                        event : new ToolKit.Event(type, typeof event === "object" && event);
                    event.isTrigger = onlyHandlers ? 2 : 3;
                    null;
                    event.result = undefined;
                    if (!event.target) {
                        event.target = elem;
                    }
                    data = data == null ? [event] : ToolKit.makeArray(data, [event]);
                    chic = ToolKit.event.chic[type] || {};
                    if (!onlyHandlers && chic.trigger && chic.trigger.apply(elem, data) === false) {
                        return;
                    }
                    if (!onlyHandlers && !chic.precise && !ToolKit.isWindow(elem)) {
                        bubbleType = chic.type || type;
                        if (!rfocusMorph.test(bubbleType + type)) {
                            cur = cur.parentNode;
                        }
                        for (; cur; cur = cur.parentNode) {
                            eventPath.push(cur);
                            tmp = cur;
                        }
                        if (tmp === (elem.ownerDocument || document)) {
                            eventPath.push(tmp.defaultView || tmp.parentWindow || window);
                        }
                    }
                    i = 0;
                    while (cur = eventPath[i++]) {
                        event.type = i > 1 ? bubbleType : chic.type || type;
                        handle = ToolKit.event.get(cur, event.type) && ToolKit.event.get(cur, "handle");
                        if (handle) {
                            handle.apply(cur, data);
                        }
                        handle = ontype && cur[ontype];
                        if (handle && handle.apply && ToolKit.event.support(cur)) {
                            event.result = handle.apply(cur, data);
                            if (event.result === false) {
                                event.alter();
                            }
                        }
                    }
                    event.type = type;
                    if (!onlyHandlers) {
                        if ((!chic._default || chic._default.apply(eventPath.pop(), data) === false) && ToolKit.event.support(elem)) {
                            if (ontype && elem[type] && !ToolKit.isWindow(elem)) {
                                tmp = elem[ontype];
                                if (tmp) {
                                    elem[ontype] = null;
                                }
                                ToolKit.event.triggered = type;
                                try {
                                    elem[type]();
                                } catch (e) {}
                                ToolKit.event.triggered = undefined;
                                if (tmp) {
                                    elem[ontype] = tmp;
                                }
                            }
                        }
                    }
                    return event.result;
                },
                handle: function(event) {
                    event = ToolKit.event.fix(event);
                    var ret, handle,
                        args = slice.call(arguments),
                        handlers = ToolKit.event.get(this, event.type) || [],
                        chic = ToolKit.event.chic[event.type] || {};
                    args[0] = event;
                    event.delegateTarget = this;
                    var i = 0,
                        handle, matched = ToolKit.event.handlers.call(this, event, handlers);
                    if (matched == null) {
                        return;
                    }
                    event.currentTarget = matched.elem;
                    while ((handle = matched.handlers[i++]) && !event.abort()) {
                        event.handle = handle;
                        event.data = handle.data;
                        ret = ((ToolKit.event.chic[handle.type] || {}).handle || handle.handler).apply(matched.elem, args);
                        if (ret !== undefined) {
                            if ((event.result = ret) === false) {
                                event.alter();
                                event.termination();
                            }
                        }
                    }
                    if (chic.commit) {
                        chic.commit.call(this, event);
                    }
                    return event.result;
                },
                handlers: function(event, handlers) {
                    var results = [],
                        cur = event.target;
                    if (cur.nodeType && (!event.button || event.type !== "click")) {
                        if (cur === this) {
                            return {
                                elem: this,
                                handlers: handlers
                            };
                        }
                        for (; cur != this; cur = cur.parentNode || this) {
                            if (cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click")) {
                                return {
                                    elem: cur,
                                    handlers: handlers
                                };
                            }
                        }
                        return null;
                    }
                    return {
                        elem: this,
                        handlers: handlers
                    };
                },
                fix: function(event) {
                    if (event[ToolKit.kit]) {
                        return event;
                    }
                    var i, prop, copy,
                        type = event.type,
                        originalEvent = event,
                        fixHook = this.fixHooks[type];

                    if (!fixHook) {
                        this.fixHooks[type] = fixHook =
                            rmouseEvent.test(type) ? this.mouseHooks :
                            rkeyEvent.test(type) ? this.keyHooks : {};
                    }
                    copy = fixHook.props ? this.props.concat(fixHook.props) : this.props;

                    event = new ToolKit.Event(originalEvent);

                    i = copy.length;
                    while (i--) {
                        prop = copy[i];
                        event[prop] = originalEvent[prop];
                    }
                    if (!event.target) {
                        event.target = originalEvent.srcElement || document;
                    }
                    if (event.target.nodeType === 3) {
                        event.target = event.target.parentNode;
                    }
                    event.metaKey = !!event.metaKey;

                    return fixHook.filter ? fixHook.filter(event, originalEvent) : event;
                },
                props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
                fixHooks: {},
                keyHooks: {
                    props: "char charCode key keyCode".split(" "),
                    filter: function(event, original) {
                        if (event.which == null) {
                            event.which = original.charCode != null ? original.charCode : original.keyCode;
                        }

                        return event;
                    }
                },
                mouseHooks: {
                    props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
                    filter: function(event, original) {
                        var body, eventDoc, doc,
                            button = original.button,
                            fromElement = original.fromElement;
                        if (event.pageX == null && original.clientX != null) {
                            eventDoc = event.target.ownerDocument || document;
                            doc = eventDoc.documentElement;
                            body = eventDoc.body;

                            event.pageX = original.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
                            event.pageY = original.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
                        }
                        if (!event.relatedTarget && fromElement) {
                            event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
                        }
                        if (!event.which && button !== undefined) {
                            event.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0)));
                        }

                        return event;
                    }
                },
                chic: {
                    load: {
                        precise: true
                    },
                    focus: {
                        trigger: function() {
                            if (this !== safeActiveElement() && this.focus) {
                                try {
                                    this.focus();
                                    return false;
                                } catch (e) {}
                            }
                        }
                    },
                    blur: {
                        trigger: function() {
                            if (this === safeActiveElement() && this.blur) {
                                this.blur();
                                return false;
                            }
                        }
                    },
                    click: {
                        trigger: function() {
                            if (ToolKit.nodeName(this, "input") && this.type === "checkbox" && this.click) {
                                this.click();
                                return false;
                            }
                        },
                        _default: function(event) {
                            return ToolKit.nodeName(event.target, "a");
                        }
                    },
                    beforeunload: {
                        commit: function(event) {
                            if (event.result !== undefined && event.originalEvent) {
                                event.originalEvent.returnValue = event.result;
                            }
                        }
                    }
                }
            }; ToolKit.addEvent = document.addEventListener ? function(elem, type, handle) {
                if (elem.addEventListener) {
                    elem.addEventListener(type, handle, false);
                }
            } : function(elem, type, handle) {
                if (elem.attachEvent) {
                    elem.attachEvent("on" + type, handle);
                }
            }; ToolKit.removeEvent = document.removeEventListener ?
            function(elem, type, handle) {
                if (elem.removeEventListener) {
                    elem.removeEventListener(type, handle, false);
                }
            } :
            function(elem, type, handle) {
                var name = "on" + type;
                if (elem.detachEvent) {
                    if (elem[name] === undefined) {
                        elem[name] = null;
                    }
                    elem.detachEvent(name, handle);
                }
            }; ToolKit.Event = function(src, props) {
                if (!(this instanceof ToolKit.Event)) {
                    return new ToolKit.Event(src, props);
                }
                if (src && src.type) {
                    this.originalEvent = src;
                    this.type = src.type;
                } else {
                    this.type = src;
                }
                if (props) {
                    ToolKit.extend(this, props);
                }
                this.timeStamp = src && src.timeStamp || +(new Date());
                this[ToolKit.kit] = true;
            }; ToolKit.Event.prototype = {
                abort: returnFalse,
                alter: function() {
                    var e = this.originalEvent;
                    if (!e) {
                        return;
                    }
                    if (e.alter) {
                        e.alter();
                    } else {
                        e.returnValue = false;
                    }
                },
                termination: function() {
                    var e = this.originalEvent;
                    this.abort = returnTrue;
                    if (!e) {
                        return;
                    }
                    if (e.termination) {
                        e.termination();
                    }
                    e.cancelBubble = true;
                }
            };

            ToolKit.each({
                mouseenter: "mouseover",
                mouseleave: "mouseout",
                pointerenter: "pointerover",
                pointerleave: "pointerout"
            }, function(key, fix) {
                ToolKit.event.chic[key] = {
                    type: fix,
                    handle: function(event) {
                        var ret,
                            target = this,
                            related = event.relatedTarget,
                            handle = event.handle;
                        if (!related || (related !== target && !ToolKit.contains(target, related))) {
                            event.type = handle.type;
                            ret = handle.handler.apply(this, arguments);
                            event.type = fix;
                        }
                        return ret;
                    }
                };
            });

            var
                ContextToolKit,
                rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/;

            function manipulationTarget(elem, content) {
                return ToolKit.nodeName(elem, "table") &&
                    ToolKit.nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr") ?
                    elem.getElementsByTagName("tbody")[0] || elem.appendChild(elem.ownerDocument.createElement("tbody")) : elem;
            }
            ToolKit.fn = {
                kit: version,
                constructor: ToolKit,
                selector: null,
                context: document,
                length: 0,
                get: function(i, v) {
                    i = +i + (i < 0 ? this.length : 0);
                    return (i in this) ? this[i] : v;
                },
                toArray: function() {
                    return slice.call(this);
                },
                push: push,
                sort: arr.sort,
                splice: arr.splice
            }; ToolKit.fn.init = function(selector, context) {
                if (!selector) return this;
                var match, elem;
                this.selector = selector;
                if (typeof selector === "string") {
                    if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length > 2) {
                        match = [null, selector, null];
                    } else {
                        match = rquickExpr.exec(selector);
                    }
                    if (match && (match[1] || !context)) {
                        if (match[1]) {
                            context = context instanceof ToolKit ? context[0] : context;
                            ToolKit.merge(this, ToolKit.parseHTML(
                                match[1],
                                context && context.nodeType ? context.ownerDocument || context : document,
                                true
                            ));
                            if (rsingleTag.test(match[1]) && ToolKit.isPlainObject(context)) {
                                for (match in context) {
                                    if (ToolKit.isFunction(this[match])) {
                                        this[match](context[match]);
                                    } else {
                                        this.attr(match, context[match]);
                                    }
                                }
                            }
                            return this;
                        } else {
                            elem = document.getElementById(match[2]);
                            if (elem && elem.parentNode) {
                                this[0] = elem;
                                this.length = 1;
                            }
                            this.context = document;
                            return this;
                        }
                    }
                    if (!context || context.kit === version) {
                        return (context || ContextToolKit).find(selector);
                    }
                    return this.constructor(context).find(selector);
                }
                if (selector.nodeType) {
                    this.context = this[0] = selector;
                    this.length = 1;
                    return this;
                }
                if (ToolKit.isFunction(selector)) {
                    return ContextToolKit.ready !== undefined ? ContextToolKit.ready(selector) : selector(ToolKit);
                }
                if (selector.selector != null) {
                    this.selector = selector.selector;
                    this.context = selector.context;
                }
                return ToolKit.makeArray(selector, this);
            }
            ToolKit.fn.init.prototype = ToolKit.fn;

            ToolKit.extend(ToolKit, {
                contains: contains,
                css: ToolKit.fx.init,
                attr: ToolKit.ft.init,
                filterTag: function(context, tag) {
                    tag = tag || "*";
                    var result = context.getElementsByTagName ? context.getElementsByTagName(tag) : context.querySelectorAll ? context.querySelectorAll(tag) : null;
                    if (result == null) {
                        result = [];
                        if (tag === "*" || ToolKit.nodeName(context, tag)) {
                            result.push(context);
                        }
                        for (context = context.firstChild; context; context = context.nextSibling) {
                            if (tag === "*" || ToolKit.nodeName(context, tag)) {
                                result.push(context);
                            }
                            concat.apply(result, ToolKit.filterTag(context, tag));
                        };
                        return result;
                    }
                    return tag === "*" && ToolKit.nodeName(context, tag) ? ToolKit.merge([context], result) : result;
                },
                nodeName: function(elem, tag) {
                    tag = tag || "*";
                    return elem && elem.nodeName && (tag === "*" || elem.nodeName.toLowerCase() === tag.toLowerCase());
                },
                val: function(elem) {
                    if (!elem) {
                        return null;
                    }
                    var val, hooks = ToolKit.ft.hooks[elem.type] || ToolKit.ft.hooks[elem.nodeName.toLowerCase()];
                    if (hooks && "get" in hooks && (val = hooks.get(elem, "value")) != null) {
                        return val;
                    }
                    val = elem.value;
                    return typeof val === "string" ? val.replace(/\r/g, "") : val == null ? "" : val;
                },
                text: function(elem) {
                    var result = "";
                    if (!elem || !elem.nodeType) {
                        return result;
                    }
                    var nodeType = elem.nodeType;
                    if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
                        if (typeof elem.textContent === "string") {
                            result = elem.textContent;
                        } else {
                            for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
                                result += ToolKit.text(elem);
                            }
                        }
                    } else if (nodeType === 3 || nodeType === 4) {
                        result = elem.nodeValue || "";
                    }
                    return result;
                },
                clone: function(elem, dataAndEvents, deepDataAndEvents) {
                    var clone = elem.cloneNode(true);
                    if (dataAndEvents) {
                        var
                            i = 0,
                            len, type, node, cache,
                            arr = ToolKit.filterTag(elem),
                            list = ToolKit.filterTag(clone);
                        if (deepDataAndEvents) {
                            while (!!(node = arr[i++])) {
                                if (ToolKit.event.has(node, "events")) {
                                    cache = ToolKit.event.get(node);
                                    for (type in cache.events) {
                                        ToolKit.removeEvent(list[i], type, cache.handle);
                                    }
                                    list[i][ToolKit.kit] = null;
                                }
                            }
                        } else {
                            while (!!(node = arr[i++])) {
                                if (ToolKit.event.has(node, "events")) {
                                    var handle = function(e) {
                                        if (ToolKit && (!e || ToolKit.event.triggered !== e.type)) {
                                            return ToolKit.event.handle.apply(handle.elem, arguments);
                                        }
                                    };
                                    cache = ToolKit.extend(true, {}, ToolKit.event.get(node));
                                    handle.elem = list[i];
                                    cache.handle = handle;
                                    for (type in cache.events) {
                                        ToolKit.addEvent(list[i], type, cache.handle);
                                    }
                                    ToolKit.event.cache[list[i][ToolKit.kit] = ++tookit] = cache;
                                }
                            }
                        }
                    }
                    return clone;
                },
                find: function(selector, context, results) {
                    results = results || [];
                    var type = ToolKit.type(selector);
                    if (type === "string") {
                        return ToolKit.fs.init(selector, context, results);
                    }
                    if (type === "function") {
                        var val;
                        if ((val = selector.call(context, context, results)) != null && val.nodeType) {
                            results.push(val);
                        }
                        return results;
                    }
                    var list = ToolKit.merge([], selector);
                    for (var i = 0, len = list.length; i < len; i++) {
                        if (ToolKit.contains(context, list[i])) {
                            results.push(list[i]);
                        }
                    }
                    return results;
                },
                filter: function(selector, context) {
                    var type = ToolKit.type(selector);
                    if (type === "string") {
                        return ToolKit.fs.matchesSelector(selector, context);
                    }
                    if (type === "function") {
                        return selector.call(context, context);
                    }
                    var list = ToolKit.merge([], selector);
                    for (var i = 0, len = list.length; i < len; i++) {
                        if (list[i] == context) return true;
                    }
                    return false;
                }
            }); ToolKit.extend(ToolKit.fn, {
                eq: function(i) {
                    i = +i + (i < 0 ? this.length : 0);
                    return this.pushStack((i in this) ? [this[i]] : []);
                },
                first: function() {
                    return this.eq(0);
                },
                last: function() {
                    return this.eq(-1);
                },
                each: function(iterator) {
                    return ToolKit.each(this, iterator);
                },
                end: function() {
                    return this.prevObject || this.constructor();
                },
                map: function(iterator) {
                    return this.pushStack(ToolKit.map(this, function(elem, i) {
                        return iterator.call(elem, i, elem);
                    }));
                },
                pushStack: function(elems) {
                    var result = ToolKit.merge(this.constructor(), elems);
                    result.prevObject = this;
                    result.context = this.context;
                    return result;
                }
            }); ToolKit.extend(ToolKit.fn, {
                css: function(key, value) {
                    var type = ToolKit.type(key);
                    if (arguments.length === 1) {
                        if (type === "string") {
                            return ToolKit.css(this[0], key);
                        }
                        if (type !== "object") {
                            return this;
                        }
                    }
                    return this.each(function() {
                        if (type === "object") {
                            return ToolKit.each(key, function(k, v) {
                                ToolKit.css(this, k, v);
                            }, this);
                        }
                        ToolKit.css(this, key, value);
                    });
                },
                val: function(value) {
                    if (arguments.length === 0) {
                        return ToolKit.val(this[0]);
                    }
                    var isFunction = ToolKit.isFunction(value);
                    return this.each(function(i) {
                        if (this.nodeType !== 1) {
                            return;
                        }
                        var
                            val = value,
                            hooks = ToolKit.ft.hooks[elem.type] || ToolKit.ft.hooks[elem.nodeName.toLowerCase()];
                        if (isFunction) {
                            val = value.call(this, i, ToolKit(this).val());
                        }
                        if (ToolKit.isArray(val)) {
                            val = ToolKit.map(val, function(value) {
                                return value == null ? "" : value + "";
                            });
                        } else {
                            val = val == null ? val : val + "";
                        }
                        if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") == null) {
                            this.value = val;
                        }
                    });
                },
                text: function(value) {
                    if (arguments.length === 0) {
                        return ToolKit.text(this[0]);
                    }
                    var isFunction = ToolKit.isFunction(value);
                    return this.empty().each(function(i) {
                        var val = value;
                        if (isFunction) {
                            val = value.call(this, i, ToolKit(this).text());
                        }
                        val = val == null ? "" : val + "";
                        this.appendChild(document.createTextNode(val));
                    });
                },
                attr: function(key, value) {
                    if (arguments.length === 1) {
                        return ToolKit.attr(this[0], key);
                    }
                    return this.each(function() {
                        ToolKit.attr(this, key, value);
                    });
                },
                removeAttr: function(key) {
                    return this.each(function() {
                        ToolKit.ft.init(this, key, null);
                    });
                },
                clone: function(dataAndEvents, deepDataAndEvents) {
                    dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
                    deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
                    return this.map(function() {
                        return ToolKit.clone(this, dataAndEvents, deepDataAndEvents);
                    });
                },
                empty: function() {
                    return this.each(function() {
                        while (this.firstChild) {
                            this.removeChild(this.firstChild);
                        }
                        if (this.options && ToolKit.nodeName(this, "select")) {
                            this.options.length = 0;
                        }
                    });
                },
                remove: function(selector) {
                    selector = selector || "*";
                    if (selector == "*") {
                        return this.removeAll();
                    }
                    var tik = this.filter(selector);
                    if (tik.length > 0) {
                        var result = this.pushStack(this.map(function() {
                            return ToolKit.inArray(this, tik) === -1 ? this : null;
                        }));
                        tik.removeAll();
                        result.selector = this.selector;
                        return result;
                    }
                    return this;
                },
                removeAll: function() {
                    this.each(function() {
                        if (this.parentNode) {
                            this.parentNode.removeChild(this)
                        }
                    });
                    return this.constructor();
                }
            }); ToolKit.each(["width", "height"], function(i, type) {
                ToolKit.fn[type] = function(v) {
                    if (arguments.length === 0) {
                        return ToolKit.css(this[0], type);
                    }
                    return this.each(function(e) {
                        ToolKit.css(this, type, v);
                    });
                }
            });

            var rclass = /[\t\r\n\f]/g, isHidden = function(elem) {
                return ToolKit.css(elem, "display") === "none" || !ToolKit.contains(elem.ownerDocument, elem);
            }; ToolKit.extend(ToolKit.fn, {
                show: function() {
                    return this.css("display", "block");
                },
                hide: function() {
                    return this.css("display", "none");
                },
                toggle: function(state) {
                    if (typeof state === "boolean") {
                        return state ? this.show() : this.hide();
                    }

                    return this.each(function() {
                        if (isHidden(this)) {
                            ToolKit(this).show();
                        } else {
                            ToolKit(this).hide();
                        }
                    });
                },
                hasClass: function(value) {
                    var result = false;
                    if (ToolKit.isFunction(value)) {
                        this.each(function() {
                            return !(result = ToolKit(this).hasClass(value.call(this, this.className)));
                        });
                        return result;
                    }
                    value = " " + value + " ";
                    this.each(function() {
                        return !(result = (this.nodeType === 1) && (" " + this.className + " ").replace(rclass, " ").indexOf(value) > -1);
                    });
                    return result;
                },
                addClass: function(value) {
                    if (value && ToolKit.isFunction(value)) {
                        return this.each(function() {
                            ToolKit(this).addClass(value.call(this, this.className));
                        });
                    }
                    if (value && ToolKit.isString(value)) {
                        var i, target, clazz, finalValue, classes = value.match(rnotwhite) || [];
                        this.each(function() {
                            target = this.nodeType === 1 && (this.className ? (" " + this.className + " ").replace(rclass, " ") : " ");
                            if (!!target) {
                                i = 0;
                                while (!!(clazz = classes[i++])) {
                                    if (target.indexOf(" " + clazz + " ") < 0) {
                                        target += clazz + " ";
                                    }
                                }
                                finalValue = ToolKit.trim(target);
                                if (this.className !== finalValue) {
                                    this.className = finalValue;
                                }
                            }
                        });
                    }
                    return this;
                },
                toggleClass: function(value, stateVal) {
                    if (typeof stateVal === "boolean") {
                        return stateVal ? this.addClass(value) : this.removeClass(value);
                    }
                    if (ToolKit.isFunction(value)) {
                        return this.each(function() {
                            ToolKit(this).toggleClass(value.call(this, this.className, stateVal), stateVal);
                        });
                    }
                    return this.each(function() {
                        if (value == null || (this.nodeType === 1) && (" " + this.className + " ").replace(rclass, " ").indexOf(value) > -1) {
                            ToolKit(this).removeClass(value);
                        } else {
                            ToolKit(this).addClass(value);
                        }
                    });
                },
                removeClass: function(value) {
                    if (value && ToolKit.isFunction(value)) {
                        return this.each(function() {
                            ToolKit(this).removeClass(value.call(this, this, this.className));
                        });
                    }
                    if (value && ToolKit.isString(value)) {
                        var i, target, clazz, finalValue, classes = value.match(rnotwhite) || [];
                        this.each(function() {
                            target = this.nodeType === 1 && (this.className ? (" " + this.className + " ").replace(rclass, " ") : " ");
                            if (!!target) {
                                i = 0;
                                while (!!(clazz = classes[i++])) {
                                    if (target.indexOf(" " + clazz + " ") >= 0) {
                                        target = target.replace(" " + clazz + " ", " ");
                                    }
                                }
                                finalValue = ToolKit.trim(target);
                                if (this.className !== finalValue) {
                                    this.className = finalValue;
                                }
                            }
                        });
                    }
                    return this;
                }
            });

            var
                rparentsprev = /^(?:parents|previous(?:All))/,
                guaranteedUnique = {
                    contents: true,
                    next: true,
                    previous: true,
                    lastChild: true,
                    firstChild: true,
                    childNodes: true
                }; ToolKit.each({
                parent: function(elem) {
                    return !!(elem = elem.parentNode) && (elem.nodeType !== 11) ? elem : null;
                },
                parents: function(elem) {
                    return ToolKit.dir(elem, "parentNode", true);
                },
                next: function(elem) {
                    return ToolKit.dir(elem, "nextSibling");
                },
                previous: function(elem) {
                    return ToolKit.dir(elem, "previousSibling");
                },
                nextAll: function(elem) {
                    return ToolKit.dir(elem, "nextSibling", true);
                },
                previousAll: function(elem) {
                    return ToolKit.dir(elem, "previousSibling", true);
                },
                lastChild: function(elem) {
                    return ToolKit.sibling(elem, "lastChild");
                },
                firstChild: function(elem) {
                    return ToolKit.sibling(elem, "firstChild");
                },
                childNodes: function(elem) {
                    return ToolKit.sibling(elem, "firstChild", true);
                },
                contents: function(elem) {
                    return ToolKit.nodeName(elem, "iframe") ?
                        elem.contentDocument || elem.contentWindow.document :
                        ToolKit.sibling(elem, "firstChild", true);
                }
            }, function(key, callback) {
                ToolKit.fn[key] = function(selector) {
                    var r = ToolKit.map(this, callback);
                    if (selector) {
                        r = ToolKit.map(r, function() {
                            if (ToolKit.filter(selector, this)) {
                                return this;
                            }
                        });
                    }
                    if (this.length > 1) {
                        if (!guaranteedUnique[key]) {
                            ToolKit.fs.uniqueSort(r);
                        }
                        if (rparentsprev.test(key)) {
                            r = r.reverse();
                        }
                    }
                    return this.pushStack(r);
                }
            });

            var
                rscript = /^$|\/(?:java|ecma)script/i,
                rclear = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g; ToolKit.extend(ToolKit.fn, {
                append: function() {
                    return this.domManip(arguments, function(elem) {
                        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
                            var target = manipulationTarget(this, elem);
                            target.appendChild(elem);
                        }
                    });
                },
                prepend: function() {
                    return this.domManip(arguments, function(elem) {
                        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
                            var target = manipulationTarget(this, elem);
                            target.insertBefore(elem, target.firstChild);
                        }
                    });
                },
                before: function() {
                    return this.domManip(arguments, function(elem) {
                        if (this.parentNode) {
                            this.parentNode.insertBefore(elem, this);
                        }
                    });
                },
                after: function() {
                    return this.domManip(arguments, function(elem) {
                        if (this.parentNode) {
                            this.parentNode.insertBefore(elem, this.nextSibling);
                        }
                    });
                },
                domManip: function(list, callbak) {
                    list = concat.apply([], list);
                    var
                        elem,
                        scripts,
                        fragment,
                        i = 0,
                        len = this.length - 1;
                    if (len > -1) {
                        fragment = buildFragment(list, this[0].ownerDocument, this);
                        scripts = ToolKit.filterTag(fragment, "script");
                        if (fragment.childNodes.length === 1) {
                            fragment = fragment.firstChild;
                        }
                        if (scripts.length) {
                            while (!!(elem = scripts[i++])) {
                                if (rscript.test(elem.type)) {
                                    if (elem.src) {
                                        ToolKit._evalUrl && ToolKit._evalUrl(elem.src);
                                    } else {
                                        ToolKit.globalEval((elem.text || elem.textContent || elem.innerHTML || "").replace(rclear, ""));
                                    }
                                }
                            }
                        }
                    }
                    return this.each(function(i) {
                        elem = fragment;
                        if (i < len) {
                            elem = ToolKit.clone(fragment, true, true);
                        }
                        callbak.call(this, elem, i);
                    });
                }
            }); ToolKit.extend(ToolKit.fn, {
                is: function(selector) {
                    return this.filter(selector).length > 0;
                },
                not: function(selector) {
                    return this.filter(":not(" + selector + ")");
                },
                find: function(selector) {
                    var
                        i = 0,
                        len = this.length,
                        results = [];
                    for (i = 0; i < len; i++) {
                        ToolKit.find(selector, this[i], results);
                    }
                    var tik = this.pushStack(len > 1 ? ToolKit.fs.uniqueSort(results) : results);
                    tik.selector = this.selector && ToolKit.isString(this.selector) ? this.selector + " " + selector : selector;
                    return tik;
                },
                filter: function(selector) {
                    return this.pushStack(this.map(function() {
                        return ToolKit.filter(selector, this) ? this : null;
                    }));
                }
            }); ToolKit.extend(ToolKit.fn, {
                hover: function(fnOver, fnOut) {
                    return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
                },
                bind: function(type, handler, data) {
                    if (!handler) {
                        return this;
                    }
                    return this.each(function() {
                        ToolKit.event.add(this, type, handler, data);
                    });
                },
                unbind: function(type, handler) {
                    return this.each(function() {
                        ToolKit.event.remove(this, type, handler);
                    });
                },
                trigger: function(type, data) {
                    return this.each(function() {
                        ToolKit.event.trigger(type, data, this);
                    });
                },
                triggerHandler: function(type, data) {
                    if (this.length > 0) {
                        return ToolKit.event.trigger(type, data, this[0], true);
                    }
                }
            }); ToolKit.each(("blur focus focusin focusout load resize scroll unload click dblclick " +
                "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
                "change select submit keydown keypress keyup error contextmenu").split(" "), function(i, type) {
                ToolKit.fn[type] = function(fn, data) {
                    return arguments.length > 0 ? this.bind(type, fn, data) : this.trigger(type);
                };
            }); ToolKit.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function(i, type) {
                ToolKit.fn[type] = function(fn) {
                    return this.bind(type, fn);
                };
            }); ContextToolKit = new ToolKit.fn.init(document);

            var
                optionsCache = {},
                rnotwhite = (/\S+/g);

            function createOptions(options) {
                var object = optionsCache[options] = {};
                ToolKit.each(options.match(rnotwhite) || [], function(_, flag) {
                    object[flag] = true;
                });
                return object;
            }

            ToolKit.Threads = function(options) {
                options = typeof options === "string" ?
                    (optionsCache[options] || createOptions(options)) :
                    ToolKit.extend({}, options);
                if (options.update) {
                    if (typeof options.update !== "fuction") {
                        options.update = null;
                    }
                }
                if (options.callbak) {
                    if (typeof options.callbak !== "fuction") {
                        options.callbak = null;
                    }
                }
                var
                    index,
                    islock,
                    list = [],
                    processing,
                    fire = function(i, callbak) {
                        if (i == index) {
                            return true;
                        }
                        processing = false;
                        if (list && (i in list)) {
                            processing = true;
                            if (!callbak || callbak.call(tik, i, index) !== false) {
                                if (options.update) {
                                    options.update.call(list[i]);
                                } else {
                                    list[i].update();
                                }
                            }
                            index = i;
                        }
                        return !processing;
                    },
                    tik = {
                        add: function() {
                            if (list) {
                                (function add(args) {
                                    ToolKit.each(args, function(_, arg) {
                                        if (arg && (options.update || typeof arg.update === "function")) {
                                            list.push(arg);
                                        }
                                    });
                                })(arguments);
                                if (index == null || index == -1 && !processing) {
                                    islock = true;
                                    fire(0);
                                    islock = false;
                                }
                            }
                            return this;
                        },
                        remove: function() {
                            if (list) {
                                ToolKit.each(arguments, function(_, arg) {
                                    var i;
                                    while ((i = ToolKit.inArray(arg, list, i)) > -1) {
                                        list.splice(i, 1);
                                        if (i < index) {
                                            index--;
                                        }
                                    }
                                });
                            }
                            return this;
                        },
                        lock: function(i, callbak) {
                            if (this.locked()) {
                                return false;
                            }
                            islock = true;
                            if (fire(i, callbak || options.callbak)) {
                                if (options.stack) {
                                    this.empty();
                                } else {
                                    this.disable();
                                }
                            }
                            islock = false;
                            return true;
                        },
                        get: function(i) {
                            if (arguments.length === 0) {
                                return list[index];
                            }
                            i = +i + (i < 0 ? list.length : 0);
                            return list[i];
                        },
                        has: function(lyt) {
                            return lyt ? ToolKit.inArray(lyt, list) > -1 : !!(list && list.length);
                        },
                        locked: function() {
                            return !!islock;
                        },
                        empty: function() {
                            list = [];
                            index = -1;
                            return this;
                        },
                        disable: function() {
                            list = index = undefined;
                            return this;
                        },
                        disabled: function() {
                            return !list;
                        },
                        next: function() {
                            return this.lock(index + 1);
                        },
                        previous: function() {
                            return this.lock(index - 1);
                        }
                    };
                return ToolKit.improve(tik, options.threads);
            }; ToolKit.Callbacks = function(options) {
                options = typeof options === "string" ?
                    (optionsCache[options] || createOptions(options)) :
                    ToolKit.extend({}, options);

                var
                    fired,
                    locked,
                    firing,
                    memory,
                    index,
                    i,
                    len,
                    list = [],
                    stack = options.stack && [],
                    fire = function(data) {
                        memory = options.memory && data;
                        i = index || 0;
                        len = list.length;
                        firing = true;
                        for (; !locked && (i < len); i++) {
                            list[i].apply(data[0], data[1]);
                        }
                        fired = true;
                        firing = false;
                        if (list) {
                            if (stack) {
                                if (stack.length) {
                                    fire(stack.shift());
                                }
                            } else if (memory) {
                                list = [];
                            } else {
                                tik.disable();
                            }
                        }
                    },
                    tik = {
                        add: function() {
                            if (list) {
                                var start = list.length;
                                (function add(args) {
                                    ToolKit.each(args, function(_, arg) {
                                        var type = ToolKit.type(arg);
                                        if (type === "function") {
                                            if (!options.unique || !tik.has(arg)) {
                                                list.push(arg);
                                            }
                                        } else if (arg && arg.length && type !== "string") {
                                            add(arg);
                                        }
                                    });
                                })(arguments);
                                if (firing) {
                                    len = list.length;
                                } else if (memory) {
                                    index = start;
                                    fire(memory);
                                }
                            }
                            return this;
                        },
                        remove: function() {
                            if (list) {
                                ToolKit.each(arguments, function(_, arg) {
                                    var index;
                                    while ((index = ToolKit.inArray(arg, list, index)) > -1) {
                                        list.splice(index, 1);
                                        if (firing) {
                                            if (index <= len) {
                                                len--;
                                            }
                                            if (index <= i) {
                                                i--;
                                            }
                                        }
                                    }
                                });
                            }
                            return this;
                        },
                        has: function(fn) {
                            return fn ? ToolKit.inArray(fn, list) > -1 : !!(list && list.length);
                        },
                        empty: function() {
                            len = 0;
                            list = [];
                            return this;
                        },
                        disable: function() {
                            list = stack = memory = undefined;
                            return this;
                        },
                        disabled: function() {
                            return !list;
                        },
                        lock: function() {
                            locked = true;
                            stack = undefined;
                            if (!memory) {
                                tik.disable();
                            }
                            return this;
                        },
                        locked: function() {
                            return !!locked;
                        },
                        fireWith: function(context, args) {
                            if (list && (!fired || stack)) {
                                args = args || [];
                                args = [context, args.slice ? args.slice() : args];
                                if (firing) {
                                    stack.push(args);
                                } else {
                                    fire(args);
                                }
                            }
                            return this;
                        },
                        fire: function() {
                            tik.fireWith(this, arguments);
                            return this;
                        },
                        fired: function() {
                            return !!fired;
                        }
                    };
                return tik;
            };

            ToolKit.Deferred = function(callbak) {
                var
                    tuples = [
                        ["resolve", "done", ToolKit.Callbacks("memory"), "resolved"],
                        ["abort", "fail", ToolKit.Callbacks("memory"), "error"],
                        ["always", "progress", ToolKit.Callbacks("stack memory")]
                    ],
                    state = "pending",
                    deferred = {},
                    promise = {
                        state: function() {
                            return state;
                        },
                        always: function() {
                            deferred.done(arguments).fail(arguments);
                            return this;
                        },
                        then: function( /* fnDone, fnFail, fnProgress */ ) {
                            var fns = arguments;
                            return ToolKit.Deferred(function(newDefer) {
                                ToolKit.each(tuples, function(i, tuple) {
                                    var fn = ToolKit.isFunction(fns[i]) && fns[i];
                                    deferred[tuple[1]](function() {
                                        var returned = fn && fn.apply(this, arguments);
                                        if (returned && ToolKit.isFunction(returned.promise)) {
                                            returned.promise()
                                                .done(newDefer.resolve)
                                                .fail(newDefer.abort)
                                                .progress(newDefer.always);
                                        } else {
                                            newDefer[tuple[0] + "With"](this === promise ? newDefer.promise() : this, fn ? [returned] : arguments);
                                        }
                                    });
                                });
                                fns = null;
                            }).promise();
                        },
                        promise: function(obj) {
                            return obj != null ? ToolKit.extend(obj, promise) : promise;
                        }
                    };
                ToolKit.each(tuples, function(i, tuple) {
                    var list = tuple[2],
                        stateString = tuple[3];
                    promise[tuple[1]] = list.add;
                    if (stateString) {
                        list.add(function() {
                            state = stateString;
                        }, tuples[i ^ 1][2].disable, tuples[2][2].lock);
                    }
                    deferred[tuple[0]] = function() {
                        deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments);
                        return this;
                    };
                    deferred[tuple[0] + "With"] = list.fireWith;
                });
                promise.promise(deferred);
                if (callbak) {
                    callbak.call(deferred, deferred);
                }
                return deferred;
            };
            var readyList; ToolKit.fn.ready = function(fn) {
                ToolKit.ready.promise().done(fn);
                return this;
            }; ToolKit.extend(ToolKit, {
                isReady: false,
                readyWait: 1,
                ready: function(wait) {
                    if (!document.body) {
                        return setTimeout(ToolKit.ready);
                    }
                    ToolKit.isReady = true;
                    readyList.resolveWith(document, [ToolKit]);
                    if (ToolKit.fn.triggerHandler) {
                        ToolKit(document).triggerHandler("ready");
                        ToolKit(document).unbind("ready");
                    }
                }
            });

            function detach() {
                if (document.addEventListener) {
                    document.removeEventListener("DOMContentLoaded", completed, false);
                    window.removeEventListener("load", completed, false);

                } else {
                    document.detachEvent("onreadystatechange", completed);
                    window.detachEvent("onload", completed);
                }
            }

            function completed() {
                if (document.addEventListener || event.type === "load" || document.readyState === "complete") {
                    detach();
                    ToolKit.ready();
                }
            }
            ToolKit.ready.promise = function(options) {
                if (!readyList) {

                    readyList = ToolKit.Deferred();
                    if (document.readyState === "complete") {
                        setTimeout(ToolKit.ready);
                    } else if (document.addEventListener) {
                        document.addEventListener("DOMContentLoaded", completed, false);
                        window.addEventListener("load", completed, false);
                    } else {
                        document.attachEvent("onreadystatechange", completed);
                        window.attachEvent("onload", completed);
                        var top = false;
                        try {
                            top = window.frameElement == null && document.documentElement;
                        } catch (e) {}

                        if (top && top.doScroll) {
                            (function doScrollCheck() {
                                if (!ToolKit.isReady) {
                                    try {
                                        top.doScroll("left");
                                    } catch (e) {
                                        return setTimeout(doScrollCheck, 50);
                                    }
                                    detach();
                                    ToolKit.ready();
                                }
                            })();
                        }
                    }
                }
                return readyList.promise(options);
            };

            var
                ajaxLocParts,
                ajaxLocation,
                r20 = /%20/g,
                rquery = (/\?/),
                rbracket = /\[\]$/,
                rCRLF = /\r?\n/g,
                rhash = /#.*$/,
                rts = /([?&])_=[^&]*/,
                rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
                rsubmittable = /^(?:input|select|textarea|keygen)/i,
                rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
                rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
                rnoContent = /^(?:GET|HEAD)$/,
                rprotocol = /^\/\//,
                rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,
                transports = {},
                prefilters = {
                    "*": [returnTrue]
                },
                nonce = +(new Date()),
                allTypes = "*/".concat("*");
            try {
                ajaxLocation = location.href;
            } catch (e) {
                ajaxLocation = document.createElement("a");
                ajaxLocation.href = "";
                ajaxLocation = ajaxLocation.href;
            }
            ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || [];

            function ajaxExtend(target, src) {
                var deep, key,
                    flatOptions = ToolKit.ajaxSettings.flatOptions || {};

                for (key in src) {
                    if (src[key] !== undefined) {
                        (flatOptions[key] ? target : (deep || (deep = {})))[key] = src[key];
                    }
                }
                if (deep) {
                    ToolKit.extend(true, target, deep);
                }
                return target;
            }

            function buildParams(prefix, obj, traditional, add) {
                var name;

                if (ToolKit.isArray(obj)) {
                    ToolKit.each(obj, function(v, i) {
                        if (traditional || rbracket.test(prefix)) {
                            add(prefix, v);
                        } else {
                            buildParams(prefix + "[" + (typeof v === "object" ? i : "") + "]", v, traditional, add);
                        }
                    });

                } else if (!traditional && ToolKit.type(obj) === "object") {
                    for (name in obj) {
                        buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
                    }

                } else {
                    add(prefix, obj);
                }
            }

            function ajaxConfig(options) {
                return function(dataTypeExpression, fn) {
                    if (ToolKit.isFunction(dataTypeExpression)) {
                        fn = dataTypeExpression;
                        dataTypeExpression = "*";
                    }
                    var
                        dataType,
                        dataTypes = dataTypeExpression.toLowerCase().match(rnotwhite) || [];
                    while (!!(dataType = dataTypes.shift())) {
                        if (dataType.charAt(0) === "+") {
                            dataType = dataType.slice(1) || "*";
                            (options[dataType] = options[dataType] || []).unshift(fn);
                        } else {
                            (options[dataType] = options[dataType] || []).push(fn);
                        }
                    }
                }
            }

            function ajaxMatchConfig(configs, ajax, options, asyncXHR) {
                var fn, result;
                return (function config(type) {
                    var list = configs[type] || configs["*"] || [];
                    for (var i = 0; !!(fn = list[i++]);) {
                        if (!!(result = fn(ajax, options, asyncXHR))) {
                            if (ToolKit.isString(result)) {
                                ajax.dataTypes.unshift(result);
                                return config(result);
                            }
                            return result;
                        }
                    }
                    return config("*");
                })(ajax.dataTypes[0]);
            }

            function ajaxHandleResponses(s, asyncXHR, responses) {
                var
                    allType,
                    dataType,
                    contents = s.contents,
                    dataTypes = s.dataTypes,
                    type = dataTypes[0];
                if (type === "*") {
                    allType = s.mimeType || asyncXHR.getResponseHeader("Content-Type");
                    for (type in contents) {
                        if (contents[type] && contents[type].test(allType)) {
                            dataTypes.unshift(type);
                            break;
                        }
                    }
                }
                if (dataTypes[0] in responses) {
                    dataType = dataTypes[0];
                } else {
                    for (type in responses) {
                        if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
                            dataType = type;
                            break;
                        }
                    }
                    dataType = dataType || type;
                }
                if (dataType !== dataTypes[0]) {
                    dataTypes.unshift(dataType);
                }
                return responses[dataType];
            }

            function ajaxConvert(s, response, asyncXHR, isSuccess) {
                var
                    type,
                    convert,
                    converters = {},
                    dataTypes = s.dataTypes.slice(),
                    from = dataTypes.shift(),
                    to = dataTypes.shift();
                if (to) {
                    for (type in s.converters) {
                        converters[type.toLowerCase()] = s.converters[type];
                    }
                }
                if (isSuccess && s.dataFilter) {
                    response = s.dataFilter(response, s.dataType);
                }
                do {
                    if (s.responseFields[from]) {
                        asyncXHR[s.responseFields[from]] = response;
                    }
                    convert = converters[from + " " + to] || converters["* " + from];
                    if (!convert) {
                        for (type in converters) {
                            type = type.split(" ");
                            if ((to === type[1]) && (convert = converters[type[0] + " " + to] || converters["* " + type[0]])) {
                                break;
                            }
                        }
                    }
                    if (!!convert) {
                        try {
                            response = convert(response) || response;
                        } catch (e) {
                            return {
                                state: "parsererror",
                                error: e
                            };
                        }
                    } else {
                        return {
                            state: "parsererror",
                            error: "No conversion from " + from + " to " + to
                        };
                    }
                }
                while (!!(from = to) && !!(to = dataTypes.shift()));
                return {
                    state: "success",
                    data: response
                };
            }

            ToolKit.extend(ToolKit, {
                active: 0,
                lastModified: {},
                etag: {},
                ajaxSettings: {
                    url: ajaxLocation,
                    type: "GET",
                    dataType: "*",
                    isLocal: rlocalProtocol.test(ajaxLocParts[1]),
                    global: true,
                    processData: true,
                    async: true,
                    contentType: "application/x-www-form-urlencoded; charset=UTF-8",
                    /*
                    timeout: 0,
                    data: null,
                    username: null,
                    password: null,
                    cache: null,
                    traditional: false,
                    headers: {},
                    */
                    accepts: {
                        "*": allTypes,
                        text: "text/plain",
                        html: "text/html",
                        xml: "application/xml, text/xml",
                        json: "application/json, text/javascript",
                        script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
                    },
                    contents: {
                        xml: /xml/,
                        html: /html/,
                        json: /json/,
                        script: /(?:java|ecma)script/
                    },
                    converters: {
                        "* text": String,
                        "text html": function(text) {
                            return text;
                        },
                        "text json": JSON.parse,
                        "text xml": ToolKit.parseXML,
                        "text script": ToolKit.globalEval
                    },
                    responseFields: {
                        xml: "responseXML",
                        text: "responseText",
                        json: "responseJSON"
                    },
                    flatOptions: {
                        url: true,
                        context: true
                    }
                },
                ajaxPrefilter: ajaxConfig(prefilters),
                ajaxTransport: ajaxConfig(transports),
                ajaxSetup: function(target, settings) {
                    return settings ?
                        ajaxExtend(ajaxExtend(target, ToolKit.ajaxSettings), settings) :
                        ajaxExtend(ToolKit.ajaxSettings, target);
                },
                param: function(a, traditional) {
                    var prefix,
                        s = [],
                        add = function(key, value) {
                            value = ToolKit.isFunction(value) ? value() : (value == null ? "" : value);
                            s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
                        };
                    if (traditional === undefined) {
                        traditional = ToolKit.ajaxSettings && ToolKit.ajaxSettings.traditional;
                    }
                    if (ToolKit.isArray(a) || (a.version && !!(a = a.data) && !ToolKit.isPlainObject(a))) {
                        ToolKit.each(a, function(v) {
                            add(v.name, v.value);
                        });
                    } else {
                        for (prefix in a) {
                            buildParams(prefix, a[prefix], traditional, add);
                        }
                    }
                    return s.join("&").replace(r20, "+");
                },
                ajax: function(url, options) {
                    if (typeof url === "object") {
                        options = url;
                        url = undefined;
                    }
                    options = options || {};

                    var
                        parts,
                        i,
                        cacheURL,
                        responseHeadersString,
                        timeoutTimer,
                        fireTKits,
                        transport,
                        responseHeaders,
                        s = ToolKit.ajaxSetup({}, options),
                        callbackContext = s.context || s,
                        globalEventContext = s.context && (callbackContext.nodeType || callbackContext.kit) ?
                        ToolKit(callbackContext) : ToolKit.event,
                        deferred = ToolKit.Deferred(),
                        completeDeferred = ToolKit.Callbacks("memory"),
                        statusCode = s.statusCode || {},
                        requestHeaders = {},
                        requestHeadersNames = {},
                        state = 0,
                        strAbort = "canceled",
                        asyncXHR = {
                            readyState: 0,
                            getResponseHeader: function(key) {
                                var match;
                                if (state === 2) {
                                    if (!responseHeaders) {
                                        responseHeaders = {};
                                        while (!!(match = rheaders.exec(responseHeadersString))) {
                                            responseHeaders[match[1].toLowerCase()] = match[2];
                                        }
                                    }
                                    match = responseHeaders[key.toLowerCase()];
                                }
                                return match == null ? null : match;
                            },
                            getAllResponseHeaders: function() {
                                return state === 2 ? responseHeadersString : null;
                            },
                            setRequestHeader: function(name, value) {
                                var lname = name.toLowerCase();
                                if (!state) {
                                    name = requestHeadersNames[lname] = requestHeadersNames[lname] || name;
                                    requestHeaders[name] = value;
                                }
                                return this;
                            },
                            overrideMimeType: function(type) {
                                if (!state) {
                                    s.mimeType = type;
                                }
                                return this;
                            },
                            statusCode: function(map) {
                                var code;
                                if (map) {
                                    if (state < 2) {
                                        for (code in map) {
                                            statusCode[code] = [statusCode[code], map[code]];
                                        }
                                    } else {
                                        asyncXHR.always(map[asyncXHR.status]);
                                    }
                                }
                                return this;
                            },
                            abort: function(statusText) {
                                var finalText = statusText || strAbort;
                                if (transport) {
                                    transport.abort(finalText);
                                }
                                done(0, finalText);
                                return this;
                            }
                        };
                    deferred.promise(asyncXHR).complete = completeDeferred.add;
                    asyncXHR.success = asyncXHR.done;
                    asyncXHR.error = asyncXHR.fail;
                    s.url = ((url || s.url || ajaxLocation) + "").replace(rhash, "").replace(rprotocol, ajaxLocParts[1] + "//");
                    s.type = options.method || options.type || s.method || s.type;
                    s.dataTypes = ToolKit.trim(s.dataType || "*").toLowerCase().match(rnotwhite) || [""];
                    if (s.crossDomain == null) {
                        parts = rurl.exec(s.url.toLowerCase());
                        s.crossDomain = !!(parts &&
                            (parts[1] !== ajaxLocParts[1] || parts[2] !== ajaxLocParts[2] ||
                                (parts[3] || (parts[1] === "http:" ? "80" : "443")) !==
                                (ajaxLocParts[3] || (ajaxLocParts[1] === "http:" ? "80" : "443")))
                        );
                    }
                    if (s.data && s.processData && typeof s.data !== "string") {
                        s.data = ToolKit.param(s.data, s.traditional);
                    }
                    ajaxMatchConfig(prefilters, s, options, asyncXHR);
                    fireTKits = s.global;
                    if (fireTKits && ToolKit.active++ === 0) {
                        ToolKit.event.trigger("ajaxStart");
                    }
                    s.type = s.type.toUpperCase();
                    s.hasContent = !rnoContent.test(s.type);
                    cacheURL = s.url;
                    if (!s.hasContent) {
                        if (s.data) {
                            cacheURL = (s.url += (rquery.test(cacheURL) ? "&" : "?") + s.data);
                            delete s.data;
                        }
                        if (s.cache === false) {
                            s.url = rts.test(cacheURL) ?
                                cacheURL.replace(rts, "$1_=" + nonce++) :
                                cacheURL + (rquery.test(cacheURL) ? "&" : "?") + "_=" + nonce++;
                        }
                    }
                    if (s.ifModified) {
                        if (ToolKit.lastModified[cacheURL]) {
                            asyncXHR.setRequestHeader("If-Modified-Since", ToolKit.lastModified[cacheURL]);
                        }
                        if (ToolKit.etag[cacheURL]) {
                            asyncXHR.setRequestHeader("If-None-Match", ToolKit.etag[cacheURL]);
                        }
                    }
                    if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
                        asyncXHR.setRequestHeader("Content-Type", s.contentType);
                    }
                    asyncXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ?
                        s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") : s.accepts["*"]);
                    for (i in s.headers) {
                        asyncXHR.setRequestHeader(i, s.headers[i]);
                    }
                    if (s.beforeSend && (s.beforeSend.call(callbackContext, asyncXHR, s) === false || state === 2)) {
                        return asyncXHR.abort();
                    }
                    strAbort = "abort";
                    for (i in {
                            success: 1,
                            error: 1,
                            complete: 1
                        }) {
                        asyncXHR[i](s[i]);
                    }
                    transport = ajaxMatchConfig(transports, s, options, asyncXHR);
                    if (!transport) {
                        done(-1, "No Transport");
                    } else {
                        asyncXHR.readyState = 1;
                        if (fireTKits) {
                            globalEventContext.trigger("ajaxSend", [asyncXHR, s]);
                        }
                        if (s.async && s.timeout > 0) {
                            timeoutTimer = setTimeout(function() {
                                asyncXHR.abort("timeout");
                            }, s.timeout);
                        }

                        try {
                            state = 1;
                            transport.send(requestHeaders, done);
                        } catch (e) {
                            if (state < 2) {
                                done(-1, e);
                            } else {
                                throw e;
                            }
                        }
                    }

                    function done(status, nativeStatusText, responses, headers) {
                        var isSuccess, success, error, response, modified,
                            statusText = nativeStatusText;
                        if (state === 2) {
                            return;
                        }
                        state = 2;
                        if (timeoutTimer) {
                            clearTimeout(timeoutTimer);
                        }
                        transport = undefined;
                        responseHeadersString = headers || "";
                        asyncXHR.readyState = status > 0 ? 4 : 0;
                        isSuccess = status >= 200 && status < 300 || status === 304;
                        response = responses && ajaxHandleResponses(s, asyncXHR, responses);;
                        response = ajaxConvert(s, response, asyncXHR, isSuccess);
                        if (isSuccess) {
                            if (s.ifModified) {
                                modified = asyncXHR.getResponseHeader("Last-Modified");
                                if (modified) {
                                    ToolKit.lastModified[cacheURL] = modified;
                                }
                                modified = asyncXHR.getResponseHeader("etag");
                                if (modified) {
                                    ToolKit.etag[cacheURL] = modified;
                                }
                            }
                            if (status === 204 || s.type === "HEAD") {
                                statusText = "nocontent";
                            } else if (status === 304) {
                                statusText = "notmodified";
                            } else {
                                statusText = response.state;
                                success = response.data;
                                error = response.error;
                                isSuccess = !error;
                            }
                        } else {
                            error = statusText;
                            if (status || !statusText) {
                                statusText = "error";
                                if (status < 0) {
                                    status = 0;
                                }
                            }
                        }
                        asyncXHR.status = status;
                        asyncXHR.statusText = (nativeStatusText || statusText) + "";
                        if (isSuccess) {
                            deferred.resolveWith(callbackContext, [success, statusText, asyncXHR]);
                        } else {
                            deferred.abortWith(callbackContext, [asyncXHR, statusText, error]);
                        }
                        asyncXHR.statusCode(statusCode);
                        statusCode = undefined;

                        if (fireTKits) {
                            globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [asyncXHR, s, isSuccess ? success : error]);
                        }
                        completeDeferred.fireWith(callbackContext, [asyncXHR, statusText]);

                        if (fireTKits) {
                            globalEventContext.trigger("ajaxComplete", [asyncXHR, s]);
                            if (!(--ToolKit.active)) {
                                ToolKit.event.trigger("ajaxStop");
                            }
                        }
                    }
                    return asyncXHR;
                }
            });

            ToolKit.each(["get", "post"], function(i, method) {
                ToolKit[method] = function(url, data, callback, type) {
                    if (ToolKit.isFunction(data)) {
                        type = type || callback;
                        callback = data;
                        data = undefined;
                    }
                    return ToolKit.ajax({
                        url: url,
                        type: method,
                        data: data,
                        dataType: type || "json",
                        success: callback
                    });
                };
            }); ToolKit._evalUrl = function(url) {
                return ToolKit.ajax({
                    url: url,
                    type: "GET",
                    dataType: "script",
                    async: false,
                    global: false
                });
            };

            function createStandardXHR() {
                try {
                    return new window.XMLHttpRequest();
                } catch (e) {}
            }

            function createActiveXHR() {
                try {
                    return new window.ActiveXObject("Microsoft.XMLHTTP");
                } catch (e) {
                    try {
                        return new window.ActiveXObject("Msxml2.XMLHTTP");
                    } catch (e) {}
                }
            }
            ToolKit.ajaxSettings.xhr = window.ActiveXObject !== undefined ?
            function() {
                return !this.isLocal && /^(get|post|head|put|delete|options)$/i.test(this.type) && createStandardXHR() || createActiveXHR();
            } : createStandardXHR;

            var xhrId = 0,
                xhrCallbacks = {},
                xhrSupported = ToolKit.ajaxSettings.xhr();
            if (window.ActiveXObject) {
                ToolKit(window).bind("unload", function() {
                    for (var key in xhrCallbacks) {
                        xhrCallbacks[key](undefined, true);
                    }
                });
            }
            support.cors = !!xhrSupported && ("withCredentials" in xhrSupported); xhrSupported = support.ajax = !!xhrSupported;

            ToolKit.ajaxPrefilter("script", function(s) {
                if (s.cache === undefined) {
                    s.cache = false;
                }
                if (s.crossDomain) {
                    s.type = "GET";
                    s.global = false;
                }
                return true;
            }); ToolKit.ajaxTransport("script", function(s) {
                if (s.crossDomain) {
                    var script,
                        head = document.head || ToolKit("head")[0] || document.documentElement;
                    return {
                        send: function(_, callback) {
                            script = document.createElement("script");
                            script.async = true;
                            if (s.scriptCharset) {
                                script.charset = s.scriptCharset;
                            }
                            script.src = s.url;
                            script.onload = script.onreadystatechange = function(_, isAbort) {
                                if (isAbort || !script.readyState || /loaded|complete/.test(script.readyState)) {
                                    script.onload = script.onreadystatechange = null;
                                    if (script.parentNode) {
                                        script.parentNode.removeChild(script);
                                    }
                                    script = null;
                                    if (!isAbort) {
                                        callback(200, "success");
                                    }
                                }
                            };
                            head.insertBefore(script, head.firstChild);
                        },

                        abort: function() {
                            if (script) {
                                script.onload(undefined, true);
                            }
                        }
                    };
                }
            });

            if (xhrSupported) {
                ToolKit.ajaxTransport(function(options) {
                    if (!options.crossDomain || support.cors) {
                        var callback;
                        return {
                            send: function(headers, complete) {
                                var i,
                                    xhr = options.xhr(),
                                    id = ++xhrId;
                                xhr.open(options.type, options.url, options.async, options.username, options.password);
                                if (options.xhrFields) {
                                    for (i in options.xhrFields) {
                                        xhr[i] = options.xhrFields[i];
                                    }
                                }
                                if (options.mimeType && xhr.overrideMimeType) {
                                    xhr.overrideMimeType(options.mimeType);
                                }
                                if (!options.crossDomain && !headers["X-Requested-With"]) {
                                    headers["X-Requested-With"] = "XMLHttpRequest";
                                }
                                for (i in headers) {
                                    if (headers[i] !== undefined) {
                                        xhr.setRequestHeader(i, headers[i] + "");
                                    }
                                }
                                xhr.send((options.hasContent && options.data) || null);
                                callback = function(_, isAbort) {
                                    var status, statusText, responses;
                                    if (callback && (isAbort || xhr.readyState === 4)) {
                                        delete xhrCallbacks[id];
                                        callback = undefined;
                                        xhr.onreadystatechange = null;
                                        if (isAbort) {
                                            if (xhr.readyState !== 4) {
                                                xhr.abort();
                                            }
                                        } else {
                                            responses = {};
                                            status = xhr.status;
                                            if (typeof xhr.responseText === "string") {
                                                responses.text = xhr.responseText;
                                            }
                                            try {
                                                statusText = xhr.statusText;
                                            } catch (e) {
                                                statusText = "";
                                            }
                                            if (!status && options.isLocal && !options.crossDomain) {
                                                status = responses[options.responseFields[options.dataTypes[0]]] ? 200 : 404;
                                            } else if (status === 1223) {
                                                status = 204;
                                            }
                                        }
                                    }
                                    if (responses) {
                                        complete(status, statusText, responses, xhr.getAllResponseHeaders());
                                    }
                                };

                                if (!options.async) {
                                    callback();
                                } else if (xhr.readyState === 4) {
                                    setTimeout(callback);
                                } else {
                                    xhr.onreadystatechange = xhrCallbacks[id] = callback;
                                }
                            },
                            abort: function() {
                                if (callback) {
                                    callback(undefined, true);
                                }
                            }
                        };
                    }
                });
            }

            ToolKit(function() {
                var val, div, body, container;

                body = document.getElementsByTagName("body")[0];
                if (!body || !body.style) {
                    return;
                }
                div = document.createElement("div");
                container = document.createElement("div");
                container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
                body.appendChild(container).appendChild(div);

                if (div.style.zoom !== undefined) {
                    div.style.cssText = "display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1;";
                    support.inlineBlockNeedsLayout = val = div.offsetWidth === 3;
                    if (val) {
                        body.style.zoom = 1;
                    }
                }
                body.removeChild(container);
            });

            window.ToolKit = window.$ = ToolKit;
            return ToolKit;
        })(window);
View Code

 

ToolKit与jQuery类似的前端插件

标签:

原文地址:http://www.cnblogs.com/cntoolkit/p/5588265.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!