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

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

// 字符串部分字母大写，不改变原始字符串
String.prototype.upperCase = function(from, to){
  return this.slice(0, from) + this.slice(from, to).toLocaleUpperCase() + this.slice(to);
}

// 测试一个字符串（参数1）是否等于另一个字符串以一个分隔符（参数2）分割出的一个字段
String.prototype.boundary = function(s, split){
  return (split + this + split).indexOf(split + s + split) > -1;
}

// 测试一个字符串（参数）是否位于另一个字符串末尾
String.prototype.atLast = function(s){
  return this.length == this.lastIndexOf(s) + s.length;
}

// 返回包含双字节的字符串字节数
String.prototype.totalBytes = function(){
  return this.replace(/[^\x00-\xff]/g, "**").length;
}

// 测试字符串是否(只)包含中文字符
String.prototype.hasZh = function(only){
  return only ? /^[\u4e00-\u9fa5\uf900-\ufa2d]+$/.test(this) : /[\u4e00-\u9fa5\uf900-\ufa2d]/.test(this);
}

// 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);
    }
  }
  ;
}

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

// 类似数组的splice()方法，不同的是其将返回一个新数组
Array.prototype.cutIn=function(from, to){
  if(isNaN(from) || from>this.length || from<0){
    return false;
  }
  var to = Number(to);
  if (isNaN(to) || to<1){
    to = 0;
  }
  return this.slice(0, from).concat(arguments.slice(2)).concat(this.slice(from+to));
}

// 判断数组与参数（数组或集合）是否完全等同
Array.prototype.equals = function(arr){
  return this.length != arr.length ? false : Array.prototype.every.call(this, function(cur, i){
    var thi=this[i];
    return cur === thi || cur && cur.length!=undefined && thi && thi.length!=undefined && Array.prototype.equals.call(cur, thi);
  }
  , arr);
}
;

// 返回一个过滤了原数组中重复元素的新数组
Array.prototype.simplify = function(){
  return this.filter(function(cur){
    return this.indexOf(cur) < 0 && (this[this.length] = cur) && true;
  }
  , []);
}
;

// 绑定，传参
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 // IE 提速
eval("var " + "top,location,parent,screen,clipboardData,Option,frames,self,clientInformation,external,document,history,Image,navigator,open,close,alert,confirm,prompt,showModelessDialog,moveBy,moveTo,resizeBy,resizeTo,scrollBy,scrollTo,scroll,blur,focus,attachEvent,detachEvent,setInterval,clearInterval,setTimeout,clearTimeout,print".split(",").map(function(cur, i){
window["_"+i] = window[cur];
return cur+"=_"+i;
}
));
@*/

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

// 创建立即执行的匿名函数，保护全局变量
(function(){

  if(window.zCool) var _zCool = window.zCool;

  var zCool = window.zCool = function(selector, context){
    // 核心对象，实际返回init原型构造函数
    return new zCool.prototype.init(selector, context);
  }
  ;

  if(window.$) var _$ = window.$;

  window.$ = zCool;

  // 提取冗余相关字符匹配
  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{
            selector.trim().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){
              this.concat(cur);
            }
            , selector = []);
          }
        }
        else{
          return new zCool(context).find(selector);
        }
      }
      else if(selector.constructor == zCool){
        return selector;
      }
      // 返回zCool对象DOM集合原型
      return this.setArray(selector.constructor == Array && selector || selector.length && zCool.beArray(selector) || [selector]);
    }
    ,

    setArray : function(arr) {
      this.length = 0;
      // zCool方法对象执行了Array原型的push()方法
      Array.prototype.push.apply(this, arr);
      return this;
    }
    ,

    // 将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 $(Array.prototype.slice.call(this).concat(z.constructor == Array && z || z.constructor == zCool && Array.prototype.slice.call(z)) || z.length != undefined && zCool.beArray(z));
    }
    ,
    find : function(){

    }
    ,

    // 返回前一个元素节点集合
    prev : function(span){
      var z = new $;
      this.forEach(function(){
        Array.prototype.push.call(z, $.DOM.prev(arguments[0], span));
      }
      );
      return z;
    }
    ,

    // 返回后一个元素节点集合
    next : function(span){
      var z = new $;
      this.forEach(function(){
        Array.prototype.push.call(z, $.DOM.next(arguments[0], span));
      }
      );
      return z;
    }
    ,

    css : function(cssText){
      // 为每个元素添加内联样式
      this.forEach(function(){
        $.DOM.css(arguments[0], cssText);
      }
      );
      return this;
    }
    ,

    addClass : function(className){
      // 为每个元素添加一个样式类
      this.forEach(function(){
        $.DOM.addClass(arguments[0], className);
      }
      );
      return this;
    }
    ,

    removeClass : function(className){
      // 为每个元素添加一个样式类
      this.forEach(function(){
        $.DOM.removeClass(arguments[0], className);
      }
      );
      return this;
    }
    ,

    addEvent : function(sEventType, fnHandler){
      // 添加事件函数到每个对象
      var args = Array.prototype.slice.call(arguments);
      this.forEach(function(){
        $.Event.add.apply(null, [arguments[0]].concat(args));
      }
      );
      return this;
    }
  }
  ;
  "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.fn[sEventType] = function(fn){
      this.forEach(function(cur){
        cur["on" + sEventType] = fn;
      }
      );
      return this;
    }
    ;
  }
  );

  // 继承数组的原型方法
  zCool.acquire(Array, "indexOf", "lastIndexOf", "some", "every", /* "map", "filter", */ "forEach", "push", "pop");

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

  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 = {
      }
      ;
    }
    // 扩展zCoold自身的方法和属性
    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;
  }
  ;
  
  /// 设置和扩展DOM相关方法及属性
  zCool.extend({
    // 将DOM集合转化为数组（IE8-不能用slice原型）
    beArray : function(gather){
      zCool.beArray = !zCool.msie ? function(gather){
        return Array.prototype.slice.call(gather);
      }
      : function(gather){
        var arr=[];
        for (var i=0, l=gather.length; i<l; i++)arr[i]=gather[i];
        return arr;
      }
      return zCool.beArray(gather);
    }
    ,
    find : function(selector, context){
    }
    ,
    curtFind : function(selector, context){
      var $1=RegExp.$1, $2=RegExp.$2, $3=RegExp.$3, $4=RegExp.$4;
      if($2){
        context = document.getElementById($2);
		if(context.id != $2){
			Array.prototype.some.call(document.all[$2], function(cur){
				return cur.id == this ? (context=cur) && true : false;
			}
			, $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){
    }
    ,
    // 返回所有后代元素数组
    byTag : function(ele, tagName){
      ele = ele.getElementsByTagName(tagName || "*");
      return !ele.length ? [] : zCool.beArray(ele);
    }
    ,
    // 返回所有指定样式类的后代元素数组
    byClass : function(ele, className, tagName){
      if(document.getElementsByClassName){
        zCool.byClass = function(ele, className, tagName){
          ele = ele.getElementsByClassName(className);
          return !ele.length ? [] : tagName == "*" ? zCool.beArray(ele) : Array.prototype.filter.call(ele, function(cur){
            return !tagName || tagName == cur.tagName.toLowerCase();
          }
          );
        }
      }
      else{
        zCool.byClass = function(ele, className, tagName){
          ele = ele.getElementsByTagName(tagName || "*");
          return !ele.length ? [] : Array.prototype.filter.call(ele, function(cur){
            return this.hasClass(cur.className, className);
          }
          , zCool);
        }
      }
      ;
      return zCool.byClass(ele, className, tagName);
    }
    ,
    // 为元素添加一个或多个样式类（已有的忽略）
    addClass : function(ele, className){
      if(ele.nodeType == 1){
        var eleClass = ele.className;
        if(!eleClass){
          ele.className = className;
        }
        else{
          var sClass = className.split(/\s+/).filter(function(cur){
            return !this.boundary(cur, " ");
          }
          , eleClass).join(" ");
          if(sClass) ele.className = eleClass + " " + sClass;
        }
      }
    }
    ,
    // 为元素删除一个或多个样式类（包括重复的）
    removeClass : function(ele, className){
      if(ele.nodeType == 1){
        var eleClass = ele.className, arrClass = className.split(/\s+/);
        if(eleClass && arrClass.some(function(cur){
          return this.boundary(cur, " ")
        }
        , eleClass)){
          ele.className = eleClass.split(/\s+/).filter(function(cur){
            return this.indexOf(cur) < 0;
          }
          , arrClass).join(" ");
        }
      }
    }
    ,
    // 校验元素是否包含一个或多个样式类，ele参数可以是元素或其样式类的字符串
    hasClass : function(ele, className){
      var eleClass = ele.className || ele;
      return typeof eleClass == "string" && eleClass != "" && className.split(/\s+/).every(function(cur){
        return this.boundary(cur, " ");
      }
      , eleClass);
    }
    ,
    // 返回所有包含多个属性以及符合它们给定的匹配模式的后代元素数组
    byAttrs : function(ele, attrs, tagName){
      ele = ele.getElementsByTagName(tagName || "*");
      return !ele.length ? [] : Array.prototype.filter.call(ele, function(cur){
        return this.hasAttrs(cur, attrs);
      }
      , zCool);
    }
    ,
    // 校验元素是否包含多个属性以及符合它们给定的匹配模式
    hasAttrs : function(ele, attrs){
      return (attrs.constructor == Array ? attrs : attrs.match(zCool.reAttrs)).every(function(cur){
        return this.hasAttr(ele, cur);
      }
      , zCool);
    }
    ,
    // 校验元素是否包含一个属性以及符合其给定的匹配模式
    hasAttr : function(ele, attr){
      if(!zCool.reAttr.test(attr))return false;
      var eleAttr = ele.getAttribute(RegExp.$1), $2 = RegExp.$2.charAt(0), $3 = RegExp.$3 || RegExp.$4;
      return eleAttr!=null &&
      ($2 == "" ||
      ($2 == "=" && eleAttr == $3) ||
      ($2 == "*" && eleAttr.indexOf($3) > - 1) ||
      ($2 == "^" && eleAttr.indexOf($3) == 0) ||
      ($2 == "~" && eleAttr.boundary($3, " ")) ||
      ($2 == "|" && eleAttr.boundary($3, "-")) ||
      ($2 == "$" && eleAttr.atLast($3)));
    }
    ,
    // 匹配多属性选择器（match分组）
    reAttrs : /\[\w+(?:|[^*~|$]?=(?:"(?:(?!"\]).)*?"|'(?:(?!'\]).)*?'))\]/g
    ,
    // 匹配单属性选择器
    reAttr : /^\[(\w+)([^*~|$]?=)?(?:'((?:(?!"\]).)*?)'|"((?:(?!'\]).)*?)"|)?\]$/
    ,
    // 返回所有子元素数组
    children : function(ele){
      return Array.prototype.filter.call(ele.childNodes, function(cur){
        return cur.nodeType == 1;
      }
      );
    }
    ,
    // 返回所有兄弟元素数组
    siblingAll : function(ele){
      return Array.prototype.filter.call(ele.parentNode.childNodes, function(cur){
        return cur.nodeType == 1 && cur !== ele;
      }
      );
    }
    ,
    // 返回前一个兄弟元素节点
    prev : function(ele){
      return zCool.contextual(ele, "previousSibling");
    }
    ,
    // 返回之前的所有兄弟元素节点
    prevAll : function(ele){
      return zCool.contextAll(ele, "prev");
    }
    ,
    // 返回后一个兄弟元素节点
    next : function(ele){
      return zCool.contextual(ele, "nextSibling");
    }
    ,
    // 返回之后的所有兄弟元素节点
    nextAll : function(ele){
      return zCool.contextAll(ele, "next");
    }
    ,
    // 查找前后兄弟元素节点方法
    contextual : function(ele, ubiety){
      if( ! ele)return;
      var elem = ele[ubiety];
      return elem == undefined ? elem : elem.nodeType != 1 ? zCool.contextual(elem, ubiety) : elem;
    }
    ,
    // 查找前或后所有兄弟元素节点方法
    contextAll : function(ele, ubiety){
      var arr = [],  elem = zCool[ubiety](ele);
      while (elem){
        arr[arr.length] = elem;
        elem = zCool[ubiety](elem);
      }
      return arr;
    }
    ,
    // 返回第一个子元素节点
    first : function(ele){
      var elem = ele.firstChild;
      return elem && elem.nodeType != 1 ? zCool.next(elem) : elem;
    }
    ,
    // 返回最后一个子元素节点
    last : function(ele){
      var elem = ele.lastChild;
      return elem && elem.nodeType != 1 ? zCool.prev(elem) : elem;
    }
    ,
    // 返回before伪元素
	before: function(ele) {
		return ele.parentNode.insertBefore(elem, ele);
	}
	,
    // 返回after伪元素
	after: function() {
		return ele.parentNode.insertBefore(elem, ele.nextSibling );
	}
	,
    // 返回或写入元素内联样式（根据参数cssText设置）
    css : function(ele, cssText){
      var sCss = ele.style.cssText;
      if(cssText == undefined){
        // 若未定义，返回内联样式
        return sCss != undefined ? sCss : ele.getAttribute("style");
      }
      else if(typeof(cssText) == "string"){
        // 若为字符串，则写入并全部删除原内联样式
        sCss != undefined ? (ele.style.cssText = cssText) : ele.setAttribute("style", cssText);
      }
      else if(typeof(cssText) == "object"){
        // 若为对象（键值对形式），写入内联样式
        for(prop in cssText){
          ele.style[prop] = cssText[prop];
        }
      }
    }
    ,
    // 返回元素最终样式
    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;
    }
    ,
    // 根据参数2是否为字符串读取或写入元素的innerText
    innerText : function(ele, text){
      if(typeof text != "string"){
        return ele.innerText != undefined ? ele.innerText : ele.textContent;
      }
      else{
        ele.innerText != undefined ? (ele.innerText = text) : (ele.innerHTML = text);
      }
    }
    ,
    // 根据参数2是否为字符串读取或写入元素的innerHTML，并根据是否包含<script>标签重构innerHTML的写入方式
    innerHTML : function(ele, sHtml) {
      if(typeof sHtml != "string"){
        return ele.innerHTML;
      }
      else{
        if(!/<script(?:[^>]*)>/i.test(sHtml)){
          ele.innerHTML = sHtml;
        }
        else{
          if(zCool.msie && (/^\s*<script(?:[^>]*)>/i).test(sHtml)){
            zCool.reInnerHtml(ele, "<b style=\"display : none; \">Hack IE</b>" + sHtml);
            ele.removeChild(ele.firstChild);
          }
          else{
            zCool.reInnerHtml(ele, sHtml);
          }
        }
        return ele.innerHTML;
      }
    }
    ,
    // 提取<script>标签中的文本，再插入原来对应的空<script>元素
    reInnerHtml : function(ele, sHtml){
      if(zCool.msie || zCool.opera){
        zCool.reInnerHtml = function(ele, sHtml){
          ele.innerHTML = sHtml;
          zCool.byTag(ele, "script").forEach(function(cur){
            cur.text = cur.text;
          }
          );
        }
	  }
	  else{
        zCool.reInnerHtml = function(ele, sHtml){
          var arr = [], reScript = /(<script[^>]*>)((?:.|[\n\r])*?)(?=<\/script>)/gi;
          sHtml = sHtml.replace(reScript, function(sMatch, $1, $2){
            arr[arr.length] = $2;
            return $1;
          }
          );
          ele.innerHTML = sHtml;
          zCool.byTag(ele, "script").forEach(function(cur, i){
            cur.text = this[i];
          }
          , arr);
        }
	  }
	  return zCool.reInnerHtml(ele, sHtml);
    }
  }
  );

  /// 设置和扩展Event相关方法和属性
  zCool.extend({
    // 为元素添加事件函数，args参数为要传递给事件函数的参数的数组
    addEvent : function(oTarget, sEventType, fnHandler, args){
      this.removeEvent(oTarget, sEventType, fnHandler, args);
      var fn=zCool.eventBind(oTarget, fnHandler, args);
      var fns = oTarget["__on" + sEventType + "__"];
      fns ? (fns[fns.length] = fn) : (oTarget["__on" + sEventType + "__"] = [fn]);
      oTarget.addEventListener ?
      oTarget.addEventListener(sEventType, fn, false) :
      oTarget.attachEvent("on" + sEventType, fn);
    }
    ,
    // 删除元素事件函数，args参数为添加的事件函数参数的（全等）数组
    removeEvent : function(oTarget, sEventType, fnHandler, args){
      var fns = oTarget["__on" + sEventType + "__"];
      if(fns && fns[0]){
        args=[fnHandler].concat(args || []);
        for(var i = fns.length-1; i > -1; i -- ){
          var fn = fns[i];
          if(fn.__eventBindStamp__.equals(args)){
            oTarget.removeEventListener ?
            oTarget.removeEventListener(sEventType, fn, false) :
            oTarget.detachEvent("on" + sEventType, fn);
            fns.splice(i, 1);
            break;
          }
        }
        // 重设同值的新数组
        oTarget["__on" + sEventType + "__"] = fns.concat();
        // GC 垃圾回收，释放内存
        fns = null;
      }
    }
    ,
    // 删除元素指定某一个事件类型的所有事件函数
    removeOneEvent : function(oTarget, sEventType){
      for(sProp in oTarget){
        if(sProp == "__on" + sEventType + "__"){
          var fns = oTarget[sProp];
          fns.forEach(function(fn){
            this.removeEventListener ?
            this.removeEventListener(sEventType, fn, false) :
            this.detachEvent("on" + sEventType, fn);
          }
          , oTarget);
          // 重设空数组
          oTarget[sProp] = [];
          // GC 垃圾回收，释放内存
          fns = null;
        }
      }
    }
    ,
    // 删除元素所有事件类型的所有事件函数
    removeAllEvents : function(oTarget){
      var eventTypes = [];
      var reEventType = /^__on([a-z]+)__$/;
      for(sProp in oTarget){
        if(reEventType.test(sProp)){
          eventTypes[eventTypes.length] = RegExp.$1;
        }
      }
      eventTypes.forEach(function(sEventType){
        this.removeOneType(oTarget, sEventType);
      }
      , zCool);
    }
    ,
    // 格式化IE8-事件对象的属性和方法，保持与DOM事件一致
    formatEvent : function (oEvent, oTarget) {
      if(!oEvent)return;
      if(!oEvent.formated){
        if(zCool.msie){

          oEvent.charCode = oEvent.type == "keypress" && oEvent.keyCode || 0;
          //IE只支持冒泡，不支持捕获
          oEvent.eventPhase = 2;
          oEvent.isChar = (oEvent.charCode > 0);
          //鼠标相对于整个页面的坐标
          oEvent.pageX = oEvent.clientX + document.documentElement.scrollLeft;
          oEvent.pageY = oEvent.clientY + document.documentElement.scrollTop;
          //阻止事件的默认行为
          oEvent.preventDefault = this.preventDefault;
          //将toElement, fromElement转化为标准的relatedTarget（firefox 2和safari 3 有些微不一致）
          var sType = oEvent.type;
          oEvent.relatedTarget= sType == "mouseout" ? oEvent.toElement : sType == "mouseover" ? oEvent.fromElement : sType == "keydown" || sType == "keypress" ? undefined : null;
          //取消冒泡
          oEvent.stopPropagation = this.stopPropagation;
          //事件发生对象
          oEvent.target = oEvent.srcElement;
          //事件函数对象
          oEvent.currentTarget=oTarget;

        }
        // 事件触发初始时间，DOM2标准timeStamp目前只有Safari 3准确，firefox 2不一致，opera 9为0
        oEvent.timestamp=(new Date).getTime();
        oEvent.formated=true;
      }
      return oEvent;
    }
    ,
    //阻止事件的默认行为（防止重复创建函数，导致内存溢出）
    preventDefault : function(){
      this.returnValue = false;
    }
    ,
    //取消冒泡（同上）
    stopPropagation : function(){
      this.cancelBubble = true;
    }
    ,
    // 返回格式化后的事件对象
    getEvent : function(oTarget){
      // opera 9还不支持函数的caller属性，通过window.event获取事件（后者）（safari 3也可）
      // IE8- 内联或赋值事件调用后者（如需获取事件对象，将get()方法置于顶层内联事件的首行，参数为this）
      return zCool.regetEvent(zCool.getEvent.caller) || zCool.formatEvent(window.event, oTarget);
    }
    ,
    // 获取顶层事件函数的事件对象（arguments[0]）
    regetEvent : function(caller){
      return caller && (caller.caller == null ? caller.arguments[0] : zCool.regetEvent(caller.caller));
    }
    ,
    // 即时格式化事件对象，并对赋予事件的元素apply这个函数、传参（args为数组形式）
    eventBind: function(oTarget, fnHandler, args){
      var temp=function(e){
        zCool.formatEvent(e, oTarget);
        return fnHandler.apply(oTarget, args || []);
      }
      temp.__eventBindStamp__ = [fnHandler].concat(args || []);
      return temp;
    }
  }
  );

  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 ? RegExp.$2 : NaN;
  }
  , zCool);

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

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