/*
* zCool 0.3 - Javascript
*
* Copyright (c) 2008 zhou BaiMin (zCool.cn)
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
*
* $Date: 2009-05-28 14:28:00 BeiJing $
* $Revision: 1 $
*/

// 清除字符串首尾空白字符
String.prototype.trim = function(){
  return this.replace(/^\s+|\s+$/g, "");
}

// JS1.8
if (!Array.prototype.reduce) {
    Array.prototype.reduce = function(fun /*, initial*/){
        var len = this.length >>> 0;
        if (typeof fun != "function")
        throw new TypeError();

        // no value to return if no initial value and an empty array
        if (len == 0 && arguments.length == 1)
        throw new TypeError();

        var i = 0;
        if (arguments.length >= 2){
            var rv = arguments[1];
        }
        else{
            do{
                if (i in this){
                    rv = this[i++];
                    break;
                }

                // if array contains no values, no initial value to return
                if (++i >= len)
                throw new TypeError();
            }
            while (true);
        }

        for (; i < len; i++){
            if (i in this)
            rv = fun.call(null, rv, this[i], i, this);
        }

        return rv;
    }
    ;
}

// JS1.8
if (!Array.prototype.reduceRight) {
    Array.prototype.reduceRight = function(fun /*, initial*/)
    {
        var len = this.length >>> 0;
        if (typeof fun != "function")
        throw new TypeError();

        // no value to return if no initial value, empty array
        if (len == 0 && arguments.length == 1)
        throw new TypeError();

        var i = len - 1;
        if (arguments.length >= 2){
            var rv = arguments[1];
        }
        else{
            do{
                if (i in this){
                    rv = this[i--];
                    break;
                }

                // if array contains no values, no initial value to return
                if (--i < 0)
                throw new TypeError();
            }
            while (true);
        }

        for (; i >= 0; i--){
            if (i in this)
            rv = fun.call(null, rv, this[i], i, this);
        }

        return rv;
    }
    ;
}

// JS1.6根据是否设定的索引起始位置，向右查找并返回第一个与被参照元素一致的数组元素的索引
if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function(elt, from){
        var l = this.length;
        var from = Number(from) || 0;
        from = (from < 0) ? Math.ceil(from) : Math.floor(from);
        if (from < 0)
        from += l;
        for (; from < l; from ++ ){
            if (from in this && this[from] === elt)
            return from;
        }
        return - 1;
    }
    ;
}

// JS1.6根据是否设定的索引起始位置，向左查找并返回第一个与被参照元素一致的数组元素的索引
if (!Array.prototype.lastIndexOf) {
    Array.prototype.lastIndexOf = function(elt, from){
        var l = this.length;
        var from = Number(from);
        if (isNaN(from)){
            from = l - 1;
        }
        else{
            from = (from < 0) ? Math.ceil(from) : Math.floor(from);
            if (from < 0)
            from += l;
            else if (from >= l)
            from = l - 1;
        }
        for (; from > - 1; from -- ){
            if (from in this && this[from] === elt)
            return from;
        }
        return - 1;
    }
    ;
}

// JS1.6依序对数组中的每个元素执行一次指定的函数（callback），直到有一次返回 true
if (!Array.prototype.some) {
    Array.prototype.some = function(fun, thi){
        for (var i = 0, l = this.length; i < l; i ++ ){
            if (i in this && fun.call(thi, this[i], i, this))
            return true;
        }
        return false;
    }
    ;
}

// JS1.6依序对数组中的每个元素执行一次指定的函数（callback），直到有一次返回 false
if (!Array.prototype.every) {
    Array.prototype.every = function(fun, thi){
        for (var i = 0, l = this.length; i < l; i ++ ){
            if (i in this && ! fun.call(thi, this[i], i, this))
            return false;
        }
        return true;
    }
    ;
}

// JS1.6对数组中的每个元素都执行一次指定的函数（callback），并且以每次返回的结果为元素创建一个新数组。
if (!Array.prototype.map) {
    Array.prototype.map = function(fun, thi){
        var l = this.length, res = new Array(l);
        for (var i = 0; i < l; i ++ ){
            if (i in this)
            res[i] = fun.call(thi, this[i], i, this);
        }
        return res;
    }
    ;
}

// JS1.6对数组中的每个元素都执行一次指定的函数（callback），用执行时返回 true 的元素创建一个新数组，不改变原数组
if (!Array.prototype.filter) {
    Array.prototype.filter = function(fun, thi){
        var res = [];
        for (var i = 0, l = this.length; i < l; i ++ ){
            if (i in this){
                var val = this[i];
                if (fun.call(thi, val, i, this))
                res[res.length] = val;
            }
        }
        return res;
    }
    ;
}

// JS1.6对数组中的每个元素都执行一次指定的函数（callback）
if (!Array.prototype.forEach) {
    Array.prototype.forEach = function(fun, thi){
        for (var i = 0, l = this.length; i < l; i ++ ){
            if (i in this)
            fun.call(thi, this[i], i, this);
        }
        return this;
    }
    ;
}

//  类似数组的concat()方法，不同的是其将改变数组自身
Array.prototype.extend = function(arr){
    if(arr.constructor == Array)
    Array.prototype.push.apply(this, arr);
    return this;
}
;

// 类似数组的splice()方法，不同的是其将返回一个新数组
Array.prototype.cutIn = function(from, digit){
    var from = Number(from), digit = Number(digit);
    if (isNaN(from)){
        from = 0;
    }
    else{
        from = (from < 0) ? Math.ceil(from) : Math.floor(from);
        if (from < 0)
        from += l;
        if (from < 0)
        from = 0;
    }
    if (isNaN(digit)){
        digit = 0;
    }
    else{
        digit = (digit < 0) ? 0 : Math.floor(digit);
    }
    var arr = this.slice(0, from);
    Array.prototype.push.apply(arr, Array.prototype.slice.call(arguments, 2));
    Array.prototype.push.apply(arr, this.slice(from + to));
    return arr;
}
;

// 判断两个数组（可以是多维的）是否完全等同
Array.prototype.equals = function(arr){
    var tl = this.length;
    if(!arr || arr.constructor != Array || tl != arr.length)
    return false;
    for(var i=0; i<tl; i++){
        var thi = this[i], ari = arr[i];
        if(thi !== ari && (thi.constructor != Array || !thi.equals(ari)))
        return false;
    }
    return true;
}
;

// 返回一个过滤了原数组中重复元素的新数组
Array.prototype.simplify = function(){
    var tl = this.length, arr = [this[0]], al = 1;
    outer : for(var i=1; i<tl; i++){
        var thi = this[i];
        for(var j=0; j<al; j++){
            if(thi === arr[j])
                continue outer;
        }
        arr[al++] = thi;
    }
    return arr;
}
;

// 绑定，传参
Function.prototype.bind = function(oTarget){
    var method = this;
    return function(){
        return method.apply(oTarget, arguments);
    }
}
;

// 扩展Function对象的acquire()原型方法，用来继承其他对象的原型方法
Function.prototype.acquire = function(initiator){
    Array.prototype.slice.call(arguments, 1).forEach(function(name){
        this.prototype[name] = initiator.prototype[name];
    }
    , this);
}
;

/*@cc_on // IE6-7 提速
eval("var " + "top,location,parent,frames,frameElement,self,clipboardData,external,clientInformation,document,history,navigator,Option,open,opener,close,alert,confirm,prompt,showModelessDialog,moveBy,moveTo,resizeBy,resizeTo,scrollBy,scrollTo,scroll,attachEvent,detachEvent,setInterval,clearInterval,setTimeout,clearTimeout,print,XMLHttpRequest,Image".split(",").map(function(cur, i){
window["_"+i] = window[cur];
return cur+"=_"+i;
}
));
@*/

// IE7-缓存图像
try{
    document.execCommand("BackgroundImageCache", false, true);
}
catch(e){
}

// 创建立即执行的匿名函数，保护全局变量
(function(){
    
    var window = this,
    _zCool = window.zCool,
    _$ = window.$,
    zCool = window.zCool = window.$ = function(selector, context){
        // 核心对象，实际返回init原型构造函数
        return new zCool.prototype.init(selector, context);
    }
    ;

    // 提取冗余相关字符匹配
    var redundancy = /(?:'.*?'|".*?")(?=\s*?\])|\s*[,+>^$|()~=-]+\s*|\s+\]|[*:[]\s+|::\s+|\s{2,}/g;
    // 清除冗余空字符匹配
    var cleaner = /(^['"].*$|\S+)/;
    // 并列选择器分组匹配
    var grouping = /,(?![^']+'\]|[^"]+"\])/;
    // 后代选择器层叠匹配
    var split = /(?:^|\s|\++|>)(?!(?:[^']+'\]|[^"]+"\]))(?:.+?=('.*?'|".*?")\]|[^\s+>]+)/g;
    // 简略选择器匹配模式
    var curt = /^(\w+)?(?:#([\w-]+))?(?:(\[\w+(?:|[^*~|$]?=(?:"(?:(?!"\]).)*?"|'(?:(?!'\]).)*?'))\])|\.([\w-]+))*$/;

    zCool.fn = zCool.prototype = {

        init : function(selector, context){
            selector = selector || document;
            if (selector.nodeType) {
                this[0] = selector;
                this.length = 1;
                return this;
            }
            else if(typeof selector == "string"){
                if(!context){
                    if (curt.test(selector)){
                        selector = zCool.curtFind(selector, document);
                    }
                    else{
                        zCool.String.trim(selector).replace(redundancy, function(sMatch){
                            // 清除冗余字符 （Opera不支持静态属性——最后匹配字符RegExp.lastMatch）
                            return cleaner.test(sMatch) ? RegExp.$1 : " ";
                        }
                        // 并列选择器分组
                        ).split(grouping).map(function(cur){
                            return this.find(cur);
                        }
                        , zCool(document)).forEach(function(cur){
                            Array.prototype.push.apply(this, cur);
                        }
                        , selector = []);
                    }
                }
                else{
                    return new zCool(context).find(selector);
                }
            }
            else if(selector.zcool){
                return selector;
            }
            // 返回zCool对象DOM集合原型
            return this.setArray(selector.constructor == Array && selector || selector.length && zCool.beArray(selector) || [selector]);
        }
        ,
    
        setArray : function(arr) {
            this.length = 0;
            // 对象执行了Array原型的push()方法
            Array.prototype.push.apply(this, arr);
            return this;
        }
        ,
	
        // 将zCool对象直接转换为数组对象
        beArray : function() {
            return zCool.beArray(this);
        }
        ,

        // 将zCool对象应用数组原型的map方法返回的数组重新转换为zCool对象
        slice : function(from, to){
            return zCool(Array.prototype.slice.call(this, from, to));
        }
        ,

        // 将zCool对象应用数组原型的map方法返回的数组重新转换为zCool对象
        map : function(fun, thi){
            return zCool(Array.prototype.map.call(this, fun, thi));
        }
        ,

        // 作用同上
        filter : function(fun, thi){
            return zCool(Array.prototype.filter.call(this, fun, thi));
        }
        ,

        // 合并创建一个新的zCool对象，不改变原zCool对象
        concat : function(z){
            return $(this.slice().concat(!z && [] || z.constructor == Array && z || z.zcool && z.slice() || z.length > -1 && zCool.beArray(z)));
        }
        ,
        find : function(){

        }
        ,

        // 返回第一个元素节点集合
        first : function(){
            var arr = [this[0]];
            for(var i = 1, l = this.length; i < l; i++){
                if(arr.some(function(){
                }
                )){
		  
                }
            }
        }
        ,

        // 返回最后一个元素节点集合
        last : function(){
            return zCool(this.map(function(cur){
                return this(cur);
            }
            , zCool.last));
        }
        ,

        // 返回前一个元素节点集合
        prev : function(span){
            return zCool(this.map(function(cur){
                return this(cur);
            }
            , zCool.prev));
        }
        ,

        // 返回后一个元素节点集合
        next : function(){
            return zCool(this.map(function(cur){
                return this(cur);
            }
            , zCool.next));
        }
        ,

        css : function(cssText){
            // 为每个元素添加内联样式
            this.forEach(function(cur){
                this(cur, cssText);
            }
            , zCool.css);
            return this;
        }
        ,

        addClass : function(className){
            // 为每个元素添加一个或多个样式类
            this.forEach(function(cur){
                this(cur, className);
            }
            , zCool.addClass);
            return this;
        }
        ,

        removeClass : function(className){
            // 对每个元素删除一个或多个样式类
            this.forEach(function(cur){
                this(cur, className);
            }
            , zCool.removeClass);
            return this;
        }
        ,

        toggleClass : function(className){
            // 对每个元素增删一个或多个样式类
            this.forEach(function(cur){
                this(cur, className);
            }
            , zCool.toggleClass);
            return this;
        }
        ,

        switchClass : function(hadClass, otherClass){
            // 对每个元素切换一个或多个样式类
            this.forEach(function(cur){
                this(cur, hadClass, otherClass);
            }
            , zCool.switchClass);
            return this;
        }
        ,

        addEvent : function(sEventType, fnHandler){
            // 添加事件函数到每个对象
            this.forEach(function(cur){
                this(cur, sEventType, fnHandler);
            }
            , zCool.addEvent);
            return this;
        }
        ,

        removeEvent : function(sEventType, fnHandler){
            // 添加事件函数到每个对象
            this.forEach(function(cur){
                this(cur, sEventType, fnHandler);
            }
            , zCool.removeEvent);
            return this;
        }
        ,

        clearEventsOfOneType : function(sEventType){
            // 添加事件函数到每个对象
            this.forEach(function(cur){
                this(cur, sEventType);
            }
            , zCool.clearEventsOfOneType);
            return this;
        }
        ,

        clearEventsOfAllTypes : function(){
            // 添加事件函数到每个对象
            this.forEach(function(cur){
                this(cur);
            }
            , zCool.clearEventsOfAllTypes);
            return this;
        }
	
    }
    ;

    zCool.prototype.init.prototype = zCool.prototype;

    // 继承数组的原型方法
    zCool.acquire(Array, "indexOf", "lastIndexOf", "some", "every", /* "map", "filter", "slice", */ "forEach", "push", "pop", "cutIn", "join");
  
    "blur,focus,load,resize,scroll,unload,click,dblclick,mousedown,mouseup,mousemove,mouseover,mouseout,change,select,submit,keydown,keypress,keyup,error".split(",").forEach(function(sEventType){
        // 扩展zCool事件原型
        zCool.fn[sEventType] = function(fnHandle){
            this.forEach(function(cur){
                this(cur, sEventType, fnHandle);
            }
            , zCool.addEvent);
            return this;
        }
        ;
    }
    );

    zCool.extend = zCool.fn.extend = function() {
        // copy reference to target object
        var target = arguments[0] || {}, i = 1, al = arguments.length, deep = false, options;
        // Handle a deep copy situation
        if (target.constructor == Boolean) {
            deep = target;
            target = arguments[1] || {};
            // skip the boolean and the target
            i = 2;
        }
        // Handle case when target is a string or something (possible in deep copy)
        if ( typeof target != "object" && typeof target != "function" ){
            target = {};
        }
        // 扩展zCool自身的方法和属性
        if ( al == 1 ) {
            target = this;
            i = 0;
        }
        for ( ; i < al; i++ )
        // Only deal with non-null/undefined values
        if ( (options = arguments[ i ]) != null )
        // Extend the base object
        for ( var name in options ) {
            // 跳过，防止死循环
            if ( target === options[ name ] )
            continue;

            // Recurse if we're merging object values
            if ( deep && options[ name ] && typeof options[ name ] == "object" && target[ name ] && !options[ name ].nodeType )
            target[ name ] = zCool.extend( target[ name ], options[ name ] );

            // Don't bring in undefined values
            else if ( options[ name ] != undefined )
            target[ name ] = options[ name ];
        }
        // 返回调整后的对象
        return target;
    }
    ;

    /*zCool.extend = zCool.fn.extend = (function(){
		// 内联写入对象的方法
		var io = function(o){
        	for(var m in o){ 
             	this[m] = o[m]; 
        	} 
    	},
		// 克隆对象，以传入对象为原型
		co = function(o){
			function F(){};
			F.prototype = o;
			return new F;
		},
		oc = Object.prototype.constructor;
		
		return function(sb, sp) {
			var F = function(){}, sbp, spp = sp.prototype;
			((sbp = sb.prototype = new F()).constructor = sb).superclass = F.prototype = spp;
			
			if(spp.constructor == oc){
				spp.constructor = sp;
			}
			
        	// 返回extend后的对象
        	return sb;
    	}
	})() ;*/
  
    /// 设置和扩展DOM相关方法及属性
    zCool.extend({
        // 将类数组集合转化为数组（IE8-的DOM集合不能用slice原型）
        beArray : function(gather){
            var arr=[], l = gather.length;
            if(l){
                try{
                    arr = Array.prototype.slice.call(gather);
                }
                catch(e){
                    for(var i=0; i<l; i++)
                    arr[i] = gather[i];
                }
            }
            return arr;
        }
        ,
        // 字符串类的方法集
        String : {
            // 清除字符串(s)首尾空白字符
            trim : function(s){
                return s.replace(/^\s+|\s+$/g, "");
            }
            ,
            // 测试字符串(s)是否包含其被一个分隔符（split）分割出的字段(s1)
            boundary : function(s, s1, split){
                if(typeof split == "string"){
                	return (split + s + split).indexOf(split + s1 + split) > -1;
				}
                if(split.constructor == RegExp){
                    s = s.split(split);
                    for(var i = 0, l = s.length; i<l; i++){
                        if(s[i] == s1)
                            return true;
					}
                    return false;
                }
            }
            ,
            // 测试一个字符串(s)末尾是否包含子串(s1)
            atLast : function(s, s1){
                return s.length == s.lastIndexOf(s1) + s1.length;
            }
            ,
            // 测试字符串是否(只)包含双字节字符
            hasDoubleByte : function(s, only){
                return only ? /^[^\x00-\xff]+$/.test(s) : /[^\x00-\xff]/.test(s);
            }
            ,
            // 返回字符串字节数（该字符串可能包含了双字节字符）
            getByteLength : function(s){
                return s.replace(/[^\x00-\xff]/g, "**").length;
            }
            ,
            // 测试字符串是否(只)包含中文字符
            hasZh : function(s, only){
                return only ? /^[\u4e00-\u9fa5\uf900-\ufa2d]+$/.test(s) : /[\u4e00-\u9fa5\uf900-\ufa2d]/.test(s);
            }
            ,
            // 按字节数截取字符串（该字符串可能包含了双字节字符）
            cutByByte : function(s, byteLength, ceil){
                var i = bL = 0;
                while(bL < byteLength){
                    bL += s.charCodeAt(i++) > 127 ? 2 : 1;
                }
                return s.slice(0, bL > byteLength && ceil ? (i-1) : i);
            }
        }
        ,
	
        find : function(selector, context){
        }
        ,
    
        curtFind : function(selector, context){
            var $1=RegExp.$1, $2=RegExp.$2, $3=RegExp.$3, $4=RegExp.$4;
            if($2){
                context = zCool.byId($2);
                if(!context || $1 && context.tagName.toLowerCase() != $1){
                    return [];
                }
                if(!$3 && !$4){
                    return [context];
                }
                if(!$3){
                    return zCool.hasClass(context, selector.slice(selector.indexOf(".")+1).replace(/\./g, " ")) ? [context] : [];
                }
                if(!$4){
                    return zCool.hasAttrs(context, selector.slice(selector.indexOf("["))) ? [context] : [];
                }
                var attrs = selector.match(zCool.reAttrs).join("");
                selector = selector.replace(zCool.reAttrs, "");
                return zCool.hasClass(context, selector.slice(selector.indexOf(".")+1).replace(/\./g, " ")) && zCool.hasAttrs(context, attrs) ? [context] : [];
            }
            else{
                if(!$3 && !$4){
                    return zCool.byTag(context, $1);
                }
                if(!$3){
                    return zCool.byClass(context, selector.slice(selector.indexOf(".")+1).replace(/\./g, " "), $1);
                }
                if(!$4){
                    return zCool.byAttrs(context, selector.slice(selector.indexOf("[")), $1);
                }
                var attrs = selector.match(zCool.reAttrs).join("");
                selector = selector.replace(zCool.reAttrs, "");
                return zCool.byClass(context, selector.slice(selector.indexOf(".")+1).replace(/\./g, " "), $1).filter(function(cur){
                    return this.hasAttrs(cur, attrs);
                }
                , zCool);
            }
        }
        ,
        not : function(selector, context){
        }
        ,
        // 根据id返回一个元素，修正IE根据name也可取元素的bug
        byId : function(id){
            var ele = document.getElementById(id);
            if(ele && ele.id != id){
                ele = document.all(id);
                for(var i=0, l=ele.length; i<l; i++){
                    if(ele[i].id == id)
                    return ele[i];
                }
                return null;
            }
            return ele;
        }
        ,
        // 返回所有后代元素数组
        byTag : function(ele, tagName){
            return zCool.beArray(ele.getElementsByTagName(tagName || "*"));
        }
        ,
        // 返回所有指定样式类的后代元素数组
        byClass : function(ele, className, tagName){
            if(!tagName && ele.getElementsByClassName){
                return zCool.beArray(ele.getElementsByClassName(className));
            }
            return Array.prototype.filter.call(ele.getElementsByTagName(tagName || "*"), function(cur){
                return this(cur, className);
            }
            , zCool.hasClass);
        }
        ,
        // 为元素添加单个或多个样式类（已有的忽略）
        addClass : function(ele, className){
            if(typeof className == "string" && className != false){
                var eleClass = ele.className;
                // 若元素无样式类，直接添加
                if(eleClass == false){
                    ele.className = className;
                }
                else{
                    // 筛除已包含的样式类
                    className = zCool.String.trim(className).split(/\s+/).filter(function(cur){
                        return !this(eleClass, cur, /\s+/);
                    }
                    , zCool.String.boundary);
                    // 根据筛除的结果添加
                    if(className.length)
                    ele.className = zCool.String.trim(eleClass) + " " + className.join(" ");
                }
            }
            return ele;
        }
        ,
        // 为元素删除一个或多个样式类（包括重复的）
        removeClass : function(ele, className){
			var eleClass = ele.className;
            // 若已存在样式类
            if(eleClass != false && typeof className == "string" && className != false){
                // 筛查并清除其中要删除的样式类
                ele.className = zCool.String.trim(eleClass).split(/\s+/).filter(function(cur){
                    return !this(className, cur, /\s+/);
                }
                , zCool.String.boundary).join(" ");
            }
            return ele;
        }
        ,
	
        // 校验元素是否包含单个或多个样式类（ele参数可以是元素或其样式类的字符串）
        hasClass : function(ele, className){
            ele = ele.className || ele;
            // 若为字符串
            if(typeof className == "string" && className != false){
				if(typeof ele == "string" && ele != false){
					className = zCool.String.trim(className);
					if(className.indexOf(" ") < 0){
						return zCool.String.boundary(ele, className, " ");
					}
                	// 否则依次筛查，若有一个未包含，立刻返回假
                	return className.split(/\s+/).every(function(cur){
                   	    return this(ele, cur, /\s+/);
                	}
                	, zCool.String.boundary);
				}
                return false;
            }
			return true;
        }
        ,
		
        // 开关样式类
        toggleClass : function(ele, className){
			return zCool[zCool.hasClass(ele, className) ? "removeClass" : "addClass"](ele, className);
        }
        ,
		
        // 替换样式类(被替换和替换的只能为一个样式类，或是位序相同的多个样式类)
        replaceClass : function(ele, hadClass, replaceClass){
            // 若为字符串
            if(typeof hadClass == "string" && typeof replaceClass == "string"){
				if(hadClass != false && replaceClass != false){
					var isString = typeof ele == "string";
					var eleClass = isString ? ele : ele.className;
					if(typeof eleClass == "string" && eleClass != false){
						eleClass = zCool.String.trim(eleClass);
						hadClass = zCool.String.trim(hadClass);
						replaceClass = zCool.String.trim(replaceClass);
						if(eleClass.indexOf(" ") < 0){
							if(eleClass == hadClass){
								isString ? (ele = replaceClass) : (ele.className = replaceClass);
								return ele;
							}
						}
						else{
							var reClass = new RegExp("(^|\\s+)" + hadClass + "(?=\\s+|$)", "g");
							var tempClass = eleClass.replace(reClass, function(sMatch, sRe1){
								return sRe1 + replaceClass;
							});
							if(tempClass != eleClass){
								isString ? (ele = tempClass) : (ele.className = tempClass);
								return ele;
							}
						}
					}
				}
            }
			return ele;
        }
        ,
		
        // 切换样式类(被替换和替换的只能为一个样式类，或是位序相同的多个样式类)
        switchClass : function(ele, hadClass, replaceClass){
            // 若为字符串
            if(typeof hadClass == "string" && typeof replaceClass == "string"){
				if(hadClass != false && replaceClass != false){
					var isString = typeof ele == "string";
					var eleClass = isString ? ele : ele.className;
					if(typeof eleClass == "string" && eleClass != false){
						eleClass = zCool.String.trim(eleClass);
						hadClass = zCool.String.trim(hadClass);
						replaceClass = zCool.String.trim(replaceClass);
						if(eleClass.indexOf(" ") < 0){
							if(eleClass == hadClass){
								isString ? (ele = replaceClass) : (ele.className = replaceClass);
								return ele;
							}
							if(eleClass == replaceClass){
								isString ? (ele = hadClass) : (ele.className = hadClass);
								return ele;
							}
						}
						else{
							var reClass = new RegExp("(^|\\s+)" + hadClass + "(?=\\s+|$)", "g");
							var tempClass = eleClass.replace(reClass, function(sMatch, sRe1){
								return sRe1 + replaceClass;
							});
							if(tempClass != eleClass){
								isString ? (ele = tempClass) : (ele.className = tempClass);
								return ele;
							}
							reClass = new RegExp("(^|\\s+)" + replaceClass + "(?=\\s+|$)", "g")
							tempClass = eleClass.replace(reClass, function(sMatch, sRe1){
								return sRe1 + hadClass;
							});
							if(tempClass != eleClass){
								isString ? (ele = tempClass) : (ele.className = tempClass);
								return ele;
							}
						}
					}
				}
            }
			return ele;
        }
    ,
    // 返回所有包含多个属性以及符合它们给定的匹配模式的后代元素数组
    byAttrs : function(ele, attrs, tagName){
      ele = ele.getElementsByTagName(tagName || "*");
      return !ele.length ? [] : Array.prototype.filter.call(ele, function(cur){
        return this.hasAttr(cur, attrs);
      }
      , zCool);
    }
        ,
	
        // 校验元素是否包含多个属性以及符合它们给定的匹配模式
        hasAttrs : function(ele, attrs){
            attrs = (attrs.constructor == Array) ? attrs : attrs.match(zCool.reAttrs);
            if(!attrs)
            return false;
            for(var i=0, l=attrs.length; i<l; i++)
            if(!zCool.hasAttr(ele, attrs[i]))
            return false;
            return true;
        }
        ,
	
        // 校验元素是否包含多个属性以及符合它们给定的匹配模式
        hasAttrs : function(ele, attrs){
            var l = attrs.length;
            do{
                if(!zCool.hasAttr(ele, attrs))
                return false;
            }
            while(zCool.reAttr.lastIndex != l);
            zCool.reAttr.lastIndex = 0;
            return true;
        }
        ,
	
        // 校验元素是否包含一个属性以及符合其给定的匹配模式
        hasAttr : function(ele, attr){
            if(!zCool.reAttr.test(attr))return false;
            var $1 = RegExp.$1, eleAttr = ele.getAttributeNode($1), $2 = RegExp.$2, $3 = RegExp.$3, $5 = RegExp.$5;
            return eleAttr !== null && eleAttr.specified &&
            ($3 != "=" || typeof(eleAttr = ele.getAttribute($1, 2)) == "string" &&
            ($2 == "" && eleAttr == $5) ||
            ($2 == "*" && eleAttr.indexOf($5) > - 1) ||
            ($2 == "^" && eleAttr.indexOf($5) == 0) ||
            ($2 == "~" && zCool.String.boundary(eleAttr, $5, /\s+/)) ||
            ($2 == "|" && zCool.String.boundary(eleAttr, $5, "-")) ||
            ($2 == "$" && zCool.String.atLast(eleAttr, $5)));
        }
        ,
	
        // 匹配多属性选择器（match分组）
        reAttrs : /\[[^'"]+?(?:'.+?'|".+?")?\]/g
        ,
	
        // 匹配单属性选择器
        reAttr : /\[\s*(\w+)\s*(?:([~^*$|])?\s*(=)\s*(?:(['"]*)(.*?)\4)|)\s*\]/
        ,
        
        match: {
            ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
            CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
            NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/,
            ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
            TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/,
            CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
            POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
            PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
        }
        ,
	
        // 返回所有子元素（可限定一种标签）的集合（数组）
        children : function(ele, tagName){
            var arr = [], i = 0, ofType = typeof tagName == "string" ? false : true;
            ele = ele.firstChild;
            while(ele){
				if(ele.nodeType == 1 && (ofType || ele.tagName == tagName)){
                	arr[i++] = ele;
				}
                ele = ele.nextSibling;
            }
            return arr;
        }
        ,
	
        // 返回所有子元素（可限定一种标签）的集合（数组）
        nthChildren : function(ele, sExp, tagName){
            var arr = [], i = 0, j = 0, ofType = typeof tagName == "string" ? false : true;
            ele = ele.firstChild;
            while(ele && ele.nodeType == 1 && (ofType || ele.tagName == tagName) && (++j)){
                arr[i++] = ele;
                ele = ele.nextSibling;
            }
            return arr;
        }
        ,
		
        re: /\(\s*(even|odd|(\d*)(?:n(?:\s*([+-])\s*(\d+))?)?)\s*\)/,
		
        // 获取首或尾子元素（可限定一种标签）
        firstOrLast : function(ele, sFil, sSib, tagName){
			var ofType = typeof tagName == "string" ? true : false;
            ele = ele[sFil];
            while(ele && (ele.nodeType != 1 || (ele.nodeType == 1 && ofType && ele.tagName != tagName))){
                ele = ele[sSib];
			}
            return ele;
        }
        ,
        
        // 返回第一个子元素（可限定一种标签）
        first : function(ele, tagName){
			return zCool.firstOrLast(ele, "firstChild", "nextSibling", tagName);
        }
        ,
        
        // 返回最后一个子元素（可限定一种标签）
        last : function(ele, tagName){
			return zCool.firstOrLast(ele, "lastChild", "previousSibling", tagName);
        }
        ,
		
        // 返回前或后一个兄弟元素（可限定一种标签）
        prevOrNext : function(ele, sSib, tagName){
			var ofType = typeof tagName == "string" ? false : true;
			ele = ele[sSib];
            while(ele && ele.nodeType != 1 && (ofType || ele.tagName == tagName)){
				ele = ele[sSib];
			};
			return ele;
        }
        ,
		
        // 返回前一个兄弟元素（可限定一种标签）
        prev : function(ele, tagName){
			return zCool.prevOrNext(ele, "previousSibling", tagName);
        }
        ,
        // 返回后一个兄弟元素（可限定一种标签）
        next : function(ele, tagName){
			return zCool.prevOrNext(ele, "nextSibling", tagName);
        }
        ,
        
        // 返回所有子元素中，每种标签的首或尾元素的集合（数组）
        firstOrLastOfType : function(ele, sFil, sSib){
            var arr = [], tagNames = [], i = 0, tagName;
            ele = zCool[sFil](ele);
			if(ele){
				arr[0] = ele;
				tagNames[0] = ele.tagName;
                ele = zCool[sSib](ele);
                while(ele){
					if(!zCool.String.boundary(tagNames.join(" "), tagName = ele.tagName, " ")){
                        arr[++i] = ele;
						tagNames[i] = tagName;
					}
                    ele = zCool[sSib](ele);
                }
			}
            return arr;
        }
        ,
        
        // 返回所有子元素中，每种标签的第一个元素的集合（数组）
        firstOfType : function(ele){
            return zCool.firstOrLastOfType(ele, "first", "next");
        }
        ,
        
        // 返回所有子元素中，每种标签的最后一个元素的集合（数组）
        lastOfType : function(ele){
            return zCool.firstOrLastOfType(ele, "last", "prev");
        }
        ,
        
        // 返回之前或之后的所有兄弟元素（数组）
        prevOrNextAll : function(ele, sSib, tagName){
            var arr = [], i = 0, ofType = typeof tagName == "string" ? false : true;
			ele = ele[sSib];
            while(ele){
                if(ele.nodeType == 1 && (ofType || ele.tagName == tagName)){
                	arr[i++] = ele;
				}
                ele = ele[sSib];
            }
            return arr;
        }
        ,
        
        // 返回之前的所有兄弟元素（数组）
        prevAll : function(ele, tagName){
            return zCool.prevOrNextAll(ele, "previousSibling", tagName).reverse();
        }
        ,
		
        // 返回之后的所有兄弟元素（数组）
        nextAll : function(ele, tagName){
            return zCool.prevOrNextAll(ele, "nextSibling", tagName);
        }
        ,
		
        // 返回所有兄弟元素（数组）
        sibAll : function(ele, tagName){
			var arr = zCool.prevAll(ele, tagName);
			Array.prototype.push.apply(arr, zCool.nextAll(ele, tagName));
			return arr;
        }
        ,
		
        // 在元素之前插入并返回元素
        insertBefore: function(before, ele) {
            ele.parentNode.insertBefore(before, ele);
            return before;
        }
        ,
		
        // 在元素之后插入并返回元素
        insertAfter: function(ele, after) {
            var parent = ele.parentNode, next = ele.nextSibling;
            next ? parent.insertBefore(after, next) : parent.appendChild(after);
            return after;
        }
        ,
		
        // 返回或写入元素内联样式（根据参数cssText设置）
        css : function(ele, cssText){
            var sCss = ele.getAttribute("style");
            if(arguments.length == 1){
                // 若未定义，返回内联样式
                return typeof sCss == "string" ? sCss : ele.style.cssText;
            }
            else{
                if(typeof cssText == "string"){
                    // 若为字符串，则写入并全部删除原内联样式
                    typeof sCss == "string" ? ele.setAttribute("style", cssText) : (ele.style.cssText = cssText);
                }
                if(typeof cssText == "object"){
                    // 若为对象（键值对形式），写入内联样式
                    for(prop in cssText){
                        ele.style[prop] = cssText[prop];
                    }
                }
            }
            return ele;
        }
        ,
        append : function(parent, child){
            parent.appendChild(child);
            return parent;
        }
        ,
        appendTo : function(parent, child){
            parent.appendChild(child);
            return child;
        }
        ,
        // 返回元素最终样式
        finalStyle : function(ele, attr){
            return (ele.currentStyle || document.defaultView.getComputedStyle(ele, false))[attr];
        }
        ,
        // 返回元素相对页面的X轴向偏移值
        pageX : function(ele){
            return ele.offsetParent ? ele.offsetLeft + zCool.pageX(ele.offsetParent) : ele.offsetLeft;
        }
        ,
        // 返回元素相对页面的Y轴向偏移值
        pageY : function(ele){
            return ele.offsetParent ? ele.offsetTop + zCool.pageY(ele.offsetParent) : ele.offsetTop;
        }
        ,
        // 根据参数sText是否为字符串读取或写入元素的innerText
        innerText : function(ele, sText){
            var text = typeof ele.textContent == "string" ?  "textContent": "innerText";
            return (zCool.innerText = function(ele, sText){
                return arguments.length == 1 ? ele[text] : (ele[text] = sText);
            }
            )(arguments.length == 1 ? ele : (ele, sText));
        }
        ,
        // 根据参数sHtml是否为字符串读取或写入元素的innerHTML，并根据是否包含<script>标签重构innerHTML的写入方式
        innerHTML : function(ele, sHtml) {
            if(arguments.length == 2){
                if(zCool.msie){
                    if(!/<(?:script|style)(?:[^>]*)>/i.test(sHtml)){
                        ele.innerHTML = sHtml;
                    }
                    else{
                        if((/^\s*<(?:script|style)(?:[^>]*)>/i).test(sHtml)){
                            ele.innerHTML = "<b style=\"display : none; \">Hack IE</b>" + sHtml;
                            zCool.reInnerHtml(ele);
                            ele.removeChild(ele.firstChild);
                        }
                        else{
                            zCool.reInnerHtml(ele);
                        }
                    }
                    return ele.innerHTML;
                }
                else{
                    var newEle = ele.cloneNode(false);
                    if(zCool.firefox || !/<script(?:[^>]*)>/i.test(sHtml)){
                        newEle.innerHTML = sHtml;
                        ele.parentNode.replaceChild(newEle, ele);
                    }
                    else if(zCool.opera){
                        newEle.innerHTML = sHtml;
                        ele.parentNode.replaceChild(newEle, ele);
                        zCool.reInnerHtml(newEle);
                    }
                    else if(zCool.safari){
                        var arrScript = [], reScript = /(<script[^>]*>)([\s\S]*?)(?=<\/script>)/gi;
                        sHtml = sHtml.replace(reScript, function(sMatch, $1, $2){
                            arrScript[arrScript.length] = $2;
                            return $1;
                        }
                        );
                        newEle.innerHTML = sHtml;
                        ele.parentNode.replaceChild(newEle, ele);
                        zCool.byTag(newEle, "script").forEach(function(cur, i){
                            cur.text = this[i];
                        }
                        , arrScript);
                    }
                    return newEle.innerHTML;
                }
            }
            else{
                return ele.innerHTML;
            }
        }
        ,
        // 提取<script>标签中的文本，再插入原来对应的空<script>元素
        reInnerHtml : function(ele){
            zCool.byTag(ele, "script").forEach(function(cur){
                cur.text = cur.text;
            }
            );
        }
    }
    );
    
    zCool.DOM = {
        " " : function(ele){
        }
    };

    /// 设置和扩展Event相关方法和属性
    zCool.extend({
			   
        // 为元素的某个事件类型注册一个事件函数
        addEvent : function(oTarget, sEventType, fnHandler){
            // 若注册对象非函数，直接返回该元素
            if(typeof fnHandler != "function")
            return oTarget;
		
            // 获取该元素的eventsRegister事件集合对象属性
            // 若未定义则创建该对象属性
            var events = oTarget.eventsRegister || (oTarget.eventsRegister = {
            }
            );
	  
            // 检测eventsRegister对象是否包含该事件类型的注册函数队列
            // 若未定义则，则根据该元素内联事件函数创建该队列
            events[sEventType] = events[sEventType] || [oTarget["on" + sEventType] || null];
	  
            // 检测该队列是否已包含要注册的事件函数
            // 若未包含则追加注册
            if(events[sEventType].indexOf(fnHandler) < 0)
            events[sEventType].push(fnHandler);
		
            // 通过内联注册事件方法写入事件路由器函数
            oTarget["on" + sEventType] = zCool.eventRouter;
	  
            return oTarget;
        }
        ,
	
        // 创建一个通用的事件路由器函数
        eventRouter : function(event){
            // 格式化事件对象，获取事件类型
            event = zCool.formatEvent(event || window.event, this), type = event.type, events = this.eventsRegister;
	  
            // 依次执行该事件类型注册函数的队列
            for(var i = 0, l = events[type].length; i < l; i++){
                this.eventExecution = events[type][i];
                // 事件函数call该元素，并判断是否返回false值来中断执行事件函数队列
                if(typeof this.eventExecution == "function" && this.eventExecution(event) === false)
                return false;
            }
        }
        ,
	
        // 清除元素某个事件类型的某个事件注册函数
        removeEvent : function(oTarget, sEventType, fnHandler){
            var events = oTarget.eventsRegister, al = arguments.length;
	  
            // 若清除对象非函数，直接返回该元素
            if(al == 3 && typeof fnHandler != "function")
            return oTarget;
		
            // 若存在元素的eventsRegister事件集合对象属性
            if(events){
                // 获取该事件类型的注册函数队列
                var fnHandlers = events[sEventType];
		
                // 若存在该事件队列
                if(fnHandlers){
			
                    // 若无清除对象，或该事件队列首即为该事件注册函数
                    if(al == 2 || fnHandlers[0] === fnHandler)
                    // 清除队列首（元素初始的内联事件函数）
                    fnHandlers[0] = null;
                    else
                    // 倒序遍历该事件队列
                    for(var i = fnHandlers.length - 1; i > -1; i--)
                    // 若包含
                    if(fnHandlers[i] === fnHandler){
                        // 从该事件队列中清除
                        // 这里未使用数组的splice直接清除的方法，测试似乎存在IE的内存占用以及执行效率问题
                        var arr = fnHandlers.slice(0, i);
                        Array.prototype.push.apply(arr, fnHandlers.slice(i + 1));
                        events[sEventType] = arr;
                        break;
                    }
			  
                    // 若该事件队列长仅为1，且其为null
                    if(events[sEventType].length == 1 && events[sEventType][0] == null){
                        // 清空该内联注册事件
                        oTarget["on" + sEventType] = null;
                        // 删除该队列
                        delete events[sEventType];
                        // 清空事件集合冗余
                        zCool.clearEvents(oTarget);
                    }
                }
            }
	  
            // 否则，若无清除对象，或是内联注册事件函数即为该事件注册函数
            else if(al == 2 || oTarget["on" + sEventType] === fnHandler){
                // 清空该内联注册事件
                oTarget["on" + sEventType] = null;
                // 清理事件集合冗余
                zCool.clearEvents(oTarget);
            }
	  
            return oTarget;
        }
        ,
	
        // 删除元素某一个事件类型的事件注册函数队列
        clearEventsOfOneType : function(oTarget, sEventType){
            // 若包含该类型内联事件，清空
            if(oTarget["on" + sEventType])
            oTarget["on" + sEventType] = null;
		
            var events = oTarget.eventsRegister;
	  
            // 若存在该事件类型的注册函数队列
            if(events && events[sEventType]){
                // 删除该事件队列
                delete events[sEventType];
                // 清理事件集合冗余
                zCool.clearEvents(oTarget);
            }
	  
            return oTarget;
        }
        ,
	
        // 删除元素所有事件类型的事件注册函数队列
        clearEventsOfAllTypes : function(oTarget){
            // 遍历元素属性
            for(var prop in oTarget)
            // 若包含任何内联事件，皆清空
            if(/^on\w+$/.test(prop) && typeof oTarget[prop] == "function")
            oTarget[prop] = null;
		  
            // 若存在元素的eventsRegister事件集合对象属性，亦清空
            if(oTarget.eventsRegister)
            oTarget.eventsRegister = null;
	  
            return oTarget;
        }
        ,
	
        // 判断清理元素的eventsRegister事件集合对象属性
        clearEvents: function(oTarget){
            var events = oTarget.eventsRegister;
	  
            // 遍历eventsRegister事件集合对象属性
            for(var sEventType in events)
            //  若存在任何事件类型的注册事件队列，暨返回不做任何操作
            if(events[sEventType] != undefined)
            return oTarget;
		  
            // 否则清空
            oTarget.eventsRegister = null;
	  
            return oTarget;
        }
        ,
	
        // 格式化事件对象的属性和方法（主要是IE8-版本），保持与DOM事件标准一致
        formatEvent : function (event, oTarget) {
            // 存放原事件对象
            var _event = event;
	  
            // 复制一个原事件对象的副本
            event = zCool.extend({
            }
            , _event);
      
            // 产生事件对象的初始时间，DOM2标准timeStamp目前只有Safari 3准确，firefox 2不一致，opera 9为0
            event.timeStamp=(new Date).getTime();
      
            // 阻止事件产生时浏览器默认行为
            event.preventDefault = function(){
                // 若符合DOM事件标准，执行原事件的该方法
                if(_event.preventDefault)
                _event.preventDefault();
                // 否则为事件的返回值属性赋false值（IE）
                else
                _event.returnValue = false;
            }
	  
            // 取消事件冒泡
            event.stopPropagation = function(){
                // 若符合DOM事件标准，执行原事件的该方法
                if(_event.stopPropagation)
                _event.stopPropagation();
                // 否则为事件的取消冒泡属性赋true值（IE）
                else
                _event.cancelBubble = true;
            }
	  
            // 注册事件的元素/对象
            if(!event.currentTarget)
            event.currentTarget = oTarget;
	  
            // 产生事件的元素/对象
            if(!event.target)
            event.target = event.srcElement || document; // IE某些情况下未定义
	  
            // 产生事件的元素/对象为文本节点时，调整为父元素（safari）
            if(event.target.nodeType == 3)
            event.target = _event.target.parentNode;
	  
            // 事件的第二目标，多用于鼠标事件中（IE）
            if(!event.relatedTarget && event.fromElement)
            event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
		
            // 事件点（通常是指鼠标）相对于页面的x、y坐标
            if(typeof event.pageX != "number" && typeof event.clientX == "number"){
                var doc = document.documentElement, body = document.documentElement;
                event.pageX = event.clientX + (doc && doc.scrollLeft || body.scrollLeft || 0) - (doc.clientLeft || 0);
                event.pageY = event.clientY + (doc && doc.scrollTop || body.scrollTop || 0) - (doc.clientTop || 0);
            }
      
            // metaKey（通常为非MAC的浏览器）
            if (!event.metaKey && event.ctrlKey)
            event.metaKey = event.ctrlKey;
	  
            // 按下按键的数字代号未定义修正（firefox）
            if(event.keyCode == undefined)
            event.keyCode = 0;
	  
            // 按下按键的Unicode值
            if(event.charCode == undefined)
            event.charCode = (event.type == "keypress") ? event.keyCode : 0;
	  
            // 按键是否有字符与之相关
            if(event.isChar == undefined)
            event.isChar = (event.charCode > 0);
      
            // 按下按键的数字代号
            if (!event.which)
            event.which = event.charCode || event.keyCode;
      
            // 鼠标事件中，按下的鼠标按钮
            // 注意：某些浏览器的事件（如IE8-中click、dblclick等）中可能无法正确使用
            if (!event.which && event.button)
            event.which = (event.button & 1 ? 1 : (event.button & 2 ? 3 : (event.button & 4 ? 2 : 0)));
	  
            // IE8-只支持冒泡，不支持捕获（0-捕获阶段，1-在目标上，2-冒泡阶段）
            if(event.eventPhase == undefined)
            event.eventPhase = 2;
		
            return event;
        }
        ,
	
        // 返回格式化后的事件对象
        getEvent : function(oTarget){
            var caller = arguments.callee.caller;
	  
            // 若采用zCool事件注册的方法，且支持caller属性
            while(caller){
                if(caller.caller == zCool.eventRouter){
                    return caller.arguments[0];
                }
                caller = caller.caller;
            }
	  
            // 若不支持caller属性（opera 9.6-），或是内联函数获取事件对象
            return zCool.formatEvent(window.event || arguments.callee.caller.arguments[0], oTarget);
        }
        ,
	
        // 对赋予事件的元素apply一个函数并传参，即绑定成一个新的可以注册的事件函数
        eventBind: function(fnHandler){
            var args = Array.prototype.slice.call(arguments, 1);
            return function(){
                return fnHandler.apply(this, args);
            }
            ;
        },
            // 触发事件
            triggerEvent: function(el, type){
                if(el[type]){
                    el[type]();
                    return el;
                }
				if(el.fireEvent){
					el.fireEvent("on" + type)
					return el;
				}
                var doc = el.ownerDocument;
                if(doc.createEvent){
                    var oEvent = doc.createEvent("Events");
                    oEvent.initEvent(type, true, true);
                    el.dispatchEvent(oEvent);
                }
                return el;
            }
	
    }
    );

    var userAgent = navigator.userAgent.toLowerCase();

    // 测试浏览器及版本号
    /(msie(?!.+?opera)|mozilla(?!.+?(?:compatible|webkit))|webkit|opera)(?:.+rv|)[\/: ]([\d.]+)/.test(userAgent);

    // 设置浏览器 mozilla==firefox webkit==safari
    ["msie", "mozilla", "webkit", "opera"].forEach(function(cur){
        // 判断当前浏览器
        var zCur = this[cur] = (RegExp.$1==cur);
        // 判断当前浏览器并返回版本号
        this[cur+"Version"] = zCur ? parseFloat(RegExp.$2) : NaN;
    }
    , zCool);

    /// 设置和扩展BOM对象方法及属性
    zCool.extend({
        systemLanguage : navigator.systemLanguage || navigator.language,
        firefox : /(firefox)\/([\d.]+)/.test(userAgent),
        firefoxVersion : RegExp.$1 == "firefox" ? parseFloat(RegExp.$2) : NaN,
        safari : /([\d.]+) (safari)/.test(userAgent),
        safariVersion : RegExp.$2 == "safari" ? parseFloat(RegExp.$1) : NaN
        //location :
    }
    );

}
)();
// 匿名函数结束