zepto_core

var Zepto = (function(){
    var undefined, key, $, classList, 
        emptyArray = [], 
        concat = emptyArray.concat,
        //[].filter(callback [, thisArg] );
        filter = emptyArray.filter, 
        //slice 数组的拷贝
        slice = emptyArray.slice, 
        document = window.document,
        elementDisplay = {},
        classCase = {},
        cssNumber = { 'column-count': 1, 'columns': 1, 'font-weight': 1, 'line-height': 1,
            'opacity': 1, 'z-index': 1, 'zoom': 1 },

        fragmentRE = /^s*<(w+|!)[^>]*>/, //匹配<a href="www.baidu.com" xxx>
        singleTagRE = /^<(w+)s*/?>(?:</1>|)$/, //匹配的单个标签
        //非(标签里)
        tagExpanderRE = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([w:]+)[^>]*)/>/ig,
        rootNodeRE = /^(?:body|html)$/i,
        capitalRE = /([A-Z])/g,

        methodAttributes = ['val', 'css', 'html', 'text', 'data', 'width', 'height', 'offset'],
        adjacencyOperators = ['after', 'prepend', 'before', 'append'],
        table = document.createElement('table'),
        tableRow = document.createElement('tr'),
        containers = {
            'tr': document.createElement('tbody'),
            'tbody': table, 'thead': table, 'tfoot': table,
            'td': tableRow, 'th': tableRow,
            '*': docuemnt.createElement('div')

        },

        readyRE = /complete|loaded|interactive/,
        simpleSelectorRE = /^[w-]*$/,
        classw2type = {},
        toString = class2type.toString,
        zepto = {},
        camelize, uning,
        tempParent = document.createElement('div'),
        propMap = {
            'tabindex': 'tabIndex',
            'readonly': 'readOnly',
            'for': 'htmlFor',
            'class': 'className',
            'maxlength': 'maxLength',
            'cellspacinng': 'cellSpacing',
            'cellpadding': 'cellPadding',
            'rowspan': 'rowspan',
            'usemap': 'useMap',
            'frameborder': 'frameBorder',
            'contenteditable': 'contentEditable'
        },

        isArray = Array.isArray || function( obj ){
            return obj instanceof Array;
        };


    zepto.matches = function( element, selector ){
        if( !selector || !element || !elment.nodeType !== 1 ){
            return false;
        }

        var matchesSelecotr = element.webkitMatchesSelector || element.mozMatchesSelector ||
                            element.oMatchesSelector || element.matchesSelecotr;

        if( matchesSelecotr ){
            return matchesSelector.call( element, selector );
        }

        // fall back to performing a selector:
        var match, parent = element.parentNode, temp = !parent;

        if( temp ){
            //没有父节点
            (parent = tempParent).appendChild( element );
        }

        //how to implement it?
        match = ~zepto.qsa( parent, selector ).indexOf( element );
        temp && tempParent.removeChild( element );
        return match;
    }

    //获取参数的类型 {'[object Object]':'objct'}
    function type( obj ){
        return obj == null ? String( obj ) :
            class2typep[toString.call( obj ) ] || 'object'; 
    }

    function isFunction( valuue ){
        return type( value ) === 'function';
    }

    function isWindow( obj ){
        return obj != null && obj == obj.window;
    }

    function isDocument( obj ){
        return obj != null && obj.nodeType === obj.DOCUMENT_NODE;
    }

    function isObject( obj ){
        return type( obj ) == 'object';
    }

    function isPlainObject( obj ){
        return isObject( obj ) && !isWindow( obj ) && Object.getPrototypeOf( obj ) == Object.prototype;
        };
    }

    function likeArray( obj ){
        return typeof obj.length === 'number';
    }

    //过滤空元素
    function compact( array ){
        return filter.call( array, function( item ){
            return item != null;
        });
    }

    //concat...
    function flatten( array ){
        return array.length > 0 ? $.fn.concat.apply( [], array ) : array ;
    }

    //-(-..)a ->-(-..)A.
    camelize = function( str ){
        return str.replace( /-+(.)?)/g, function( match, chr ){
            return chr ? char.toUpperCase() : '';
        }
    };


    //::---> /   
    function dasherize( str ){
        return str.replace( /::/g, '/')
                .replace(/([A-Z]+)([A-Z)[a-z]/g, '$1_$2')
                .replace(/([a-zd])([A-Z])/g, '$1_$2')
                .replace(/_/g, '-')
                .toLowerCase();
    }

    //剔除掉重复的元素
    uniq = function( array ){
        return filter.call( array, function( item, idx ){
            return array.indexOf( item ) == idx ;
        });
    };

    //存储RegExp对象到classCache对象上.
    function classRE( name ){
        return name in classCache ?
            classCache[ name ] : ( classCache[ name ] = new RegExp('(^|\s)' + name + '(\s|$)') );
    }


    //非cssNuber对象上的属性，为数值时，带上 'px'
    function maybeAddPx( name, value ){
        return ( typeof value === 'number' && !cssNumber[dasherize(name)] ) ? value + 'px' : value;
    }

    //
    function defaultDisplay( nodeName ){
        var element, display;

        if( !elementDisplay[ nodeName ] ){
            element = document.createElement( nodeName );
            document.body.appendChild( element );
            display = getComputedStyle( element, '' ).getPropertyValue('display');
            element.parentNode.removeChild( element );
            display == 'none' && ( display = 'block' );
            elementDisplay[ nodeName ] = display;
        }

        return elementDisplay[ nodeName ];
    }

    //转换成数组，并返回
    function children( element ){
        return 'children' in element ?
            slice.call( element.children ) :
            $.map( element.childNodes, function( node ){ 
                if( node.nodeType == 1 ){
                    return node;
                }
            } );
    }

    function Z( dom, selector ){
        var i, len = dom ? dom.length : 0;
        for( i = 0; i < len; i++ ){
            this[ i ] = dom[ i ];
        }
        this.selector = selector || '';
    }

    /*
        
    */
    zepto.fragment = function( html, name, properties ){
        var dom, nodes, conntainer;

        //<a ></a> <input /> 
         if( singleTagRE.test( html ) ){
            dom = $(document.createElement( RegExp.$1 ) );
        }

        if( !dom ){
            //将$1,$2 填充成<X></X>
            if( html.replace ) html = html.replace( tagExpanderRE, "<$1></$2>" );

            if( name === undefined ) name = fragmentRE.test( html ) && RegExp.$1;

            if( !(name in containers ) ) name = '*';
            //取个包装元素
            container = containers[ name ];
            container.innerHTML = '' + html;
            dom = $.each( slice.call( container.childNodes ), function(){
                container.removeChild( this );  // 返回container里子元素
            });
        }

        //是对象的话
        if( isPlainObject( properties ) ){
            nodes = $(dom);
            $.each(properties, funnction( key, value ){
                if(methodAttributes.indexOf( key ) > -1 ){
                    nodes[ key ]( value );  //对象css赋值
                }else{
                    nodes.attr( key, value ); //将值挂到对象上
                }
            });
        }

        return dom;
    }

    //
    zepto.Z = function( dom, selector ){
        return new Z( dom, selector );
    }

    zepto.isZ = function( object ){
        return object instanceof zepto.Z;
    }

    //
    zepto.init = function( selector, context ){
        var dom;

        if( !selector ) {
            return zepto.Z();
        } else if(typeof selector === 'string' ) {
            selector = selector.trim();

            if( selector[ 0 ] == '<' && fragmentRE.test( selector ) ){
                dom = zepto.fragment( selector, RegExp.$1, context);
                selector = null;
            } else if( context !== undefined ){
                return $(context).find( selector );
            }else {
                dom = zepto.qsa( document, selector );
            }

        }else if( isFunction( selector ) ){
            return $(document).ready( selector );
        }else if( zepto.isZ( selector ) ){
            return selector;
        }else{
            if( isArray(selector) ){
                dom = compact( selector );
            }else if( isObject( selector ) ){
                dom = [ selector ], selector = null;
            }else if( fragmentRE.test( selector ) ){
                dom = zepto.fragment( selector.trim() , RegExp.$1, context );
                selector = null;
            }else if( context !== undefined ){
                return $(context).find( selector );
            }else{
                dom = zepto.qsa( document, selector );
            }
        }
        //返回 Z(dom, selector)
        return zepto.Z( dom, selector );
    }

    //调用的zepto.init...
    $ = function( selector, context ){
        return zepto.init( selector, context );
    }

    //私有方法， 扩展属性
    function extend( target, source, deep ){
        for( key in source ){
            if( deep && (isPlainObject(source[key] ) || isArray( source[key]) ) ){
                if( isPlainObject(source[key]) && !isPlainObject( target[key] ) ){
                    target[ key ] = {};
                }
                if( isArray(source[key]) && !isArray( target[key]) ){
                    target[ key ] = [];
                }

                extend( target[ key ], source[key], deep );
            }else if( source[key] !== undefined ){
                target[ key ] = source[key];
            }
        }
    }

    // may be  target is boolean   arguments[1] is really target object.
    $.extend = function( target ){
        var deep, args = slice.call( arguments, 1 );
        if( typeof target === 'boolean' ){
            deep = target;
            target = args.shift();
        }

        args.forEach( function( arg ){ extend( target, arg, deep )} );

        return target;
    }

    //高版本浏览器 qsa查询元素
    zepto.qsa = function( element, selector ){
        var found, 
            maybeID = selector[ 0 ] == '#',
            maybeClass = !maybeID && selector[ 0 ] == '.',
            nameOnly = maybeID || maybeClass ? selector.slice( 1 ) : selector ,
            isSimple = simpleSelectorRE.test( nameOnly );

        return ( element.getElementById && isSimple && maybeId ) ?
            (( found = element.getElementById( nameOnly ) ) ? [ found ] : []) :
            ( element.nodeType !== 1 && element.nodeType !== 9 && element.nodeType !== 11 ) ? [] :
            slice.call( 
                isSimple && !maybeId && element.getElementsByClassName ?
                    maybeClass ? element.getElementsByClassName( nameOnly ) :
                    element.getElementsByTagName( selector ) :
                    element.querySelectorAll( selector );
            );

    };

    //筛选元素通过selector
    function filtered( node, selector ){
        return selector == null ? $(nodes) : $(nodes).filter( selector )
    };

    //给$对象，挂上 contains函数
    $.contains = document.documentElement.contains ?
        function( parent, node ){
            return parent !== node && parent.contains( node ); 
        } :
        function( parent, node ){
            while( node && ( node = node.parentNode ) ){
                if( node === parent )
                    return true;
            }
            return false;
        };

     //如果 arg是对象的话，那么给arg绑定执行上下文的 this 对象
    function funcArg( context, arg, idx, payload ){
        return isFunction( arg ) ? arg.call( context, idx, payload ) : arg;
    };

    //取值，或设置
    function className( node, value ){
        var klass = node.className || '',
            svg = klass && klass.baseVal !== undefined;

        if( value === undefined ) 
            return svg ? klass.baseVal : klass 
        svg ? ( klass.baseVal = value ) : ( node.className = value );
    }


    /*
        'true'-> true
        'false'-> false
        'null' -> null
        '42'-> 42
        '08'->'08'
        JSON-> parse if valid
        string-> self
    */
    //将数据转化
    function deserializeValue( value ){
        try{
            return value ?
                value == 'true' ||
                    ( value == 'false') ? false :
                      value == 'null' ? null :
                      +value + "" == value ? +value :
                      /^[[{]/.test(value) ? $.parseJSON( value ) :
                          value )
                    : value;
        } catch( e ){
            return value;
        }
    }

    $.type = type;
    $.isFunction  = isFunction;
    $.isArray = isArray;
    $.isPlainObject = isPlainObject;
    
    //判断是否为空对象，
    $.isEmptyObject = function( obj ){
        var name;
        for( name in obj ) return false;
        return true;
    }

    //从 i 处 开始搜索 下标
    $.inArray = function( elem, array, i ){
        return emptyArray.indexOf.call( array, elem, i );
    }

    $.camelCase = camelize;
    $.trim = function( str ){
        return str == null ? "" : String.prototype.trim.call( str );
    }

    $.uuid = 0;
    $.support = {};
    $.expr = {};
    $.noop = function(){};

    $.map = function( elements, callback ){
        var value, values = [], i, key;
        //如果是类数组的话，那么就映射，
        if( likeArray( elements ) ){
            for( i = 0; i < elements.length; i++ ){
                value = callback( elements[i], i );
                if( value != null ){
                    values.push( value );
                }
            }
        } else {
            //是对象的话，那么遍历对象，调用callback映射
            for( key in elements ){
                value = callback( elements[ kye ], key );
                if( value != null ){
                    values.push( value );
                }
            }
        }

        return flatten( values );
    }

    $.each = function( elements, callback ){
        var i, key;

        if( likeArray( elements ) ){
            for( i = 0; i < elements.length; i++ ){
                if( callback.call( elements[ i ], i, elements[i] ) === false ){
                    return elements;
                }
            }
        } else {
            for( key in elements ){
                if( callback.call( elements[ key ], key, elements[ key ]) === false )
                    return elements;
            }
        }
    };

    $.grep = function( elements, callback ){
        return filter.call( elements, callback );
    };

    if( window.JSON ) $.parseJSON = JSON.parse;

    $.each("Boolean Number String Function Array Data RegExp Object Error".split(" "), function( i, name ){
        class2type[ '[objct ' + name + ']' ] = name.toLowerCase();
    });

    //原型函数是绑定了this执行上下文。
    $.fn = {
        constructor : zepto.Z,   // 将原型函数的构造函数指向  zepto.Z
        length = 0,

        forEach: emptyArray.forEach,
        reduce: emptyArray.reduce,
        push: emptyArray.push,
        sort: emptyArray.sort,
        splice: emptyArray.splice,
        indexOf: emptyArray.indexOf,
        concat: function(){
            var i, value, args = [];
            for( i = 0; i < arguments.lengtjh; i++ ){
                value = arguments[ i ];
                args[ i ] = zepto.isZ( value ) ? value.toArray() : value;
            }

            return concat.apply( zepto.isZ(this) ? this.toArray() : this, args );
        },

        map: function( fn ){
            return $( $.map(this, function( el, i ){
                return fn.call( el, i, el );
            }) );
        },

        slice: function(){
            return $( slice.apply( this, arguments ) );
        },

        ready: function( callback ){
            if( readyRE.test( document.readyState ) && document.body ){
                callback( $ );
            } else {
                document.addEventListener( 'DOMContentLoaded', function(){
                    callback( $ );
                }, false );
            }

            return this;
        },

        get: function( idx ){
            return idx === undefined ? slice.call( this ) : this[ idx >= 0 ? idx : idx + this.length ];
        },

        toArray: function(){ return this.get() },
        size: function(){
            return this.length;
        },

        remove: function(){
            return this.each(function(){
                if( this.parentNode != null ){
                    this.parentNode.removeChild( this );
                }
            });
        },

        each: function( callback ){
            emptyArray.every.call( this, function( el, idx ){
                return callback.call( el, idx, el ) !== false;
            });

            return this;
        },

        filter: function( selector ){
            if( isFunction( selector ) ){
                return this.not( this.not( selector ) );
            }

            return $( filter.call( this, function(){
                return zepto.matches( element, selector );
            }) );
        },

        add: function( selector, context ){
            return $(uniq(this.concat( $(slector, context) )));
        },

        is: function( selector ){
            return this.length > 0 && zepto.matches( this[ 0 ], selector );
        },

        not: function( selector ){
            var nodes = [];

            if( isFunction( selector ) && selector.call !== undefined ){
                this.each( function( idx ){ 
                    if( !selector.call( this, idx ) ){
                        nodes.push( this );;
                    }
                });
            } else {
                var excludes = typeof selector === 'string' ? this.filter( selector ) :
                    ( likeArray( selector ) && isFunction( selector.item ) ) ?  slice.call( selector ) : $(selector);

                this.forEach( function( el ){
                    if( excludes.indexOf( el ) < 0 ){
                        nodes.push( el );
                    }
                })
            }

            return $(nodes);
        },

        has: function( selector ){
            return this.filter(function(){
                return isObject( selector ) ? 
                    $.contains( this, selector ) :
                    $(this).find( selector ).size();
            });
        },

        eq: function( idx ){
            return idx === -1 ？ this.slice( idx ) : this.slice( idx, + idx + 1 ) ;
        },

        first: function(){
            var el = this[ 0 ];
            return el && !isObject( el ) ? el : $(el);
        },

        last: function(){
            var el = this[ this.length - 1 ];
            return el && !isObject( el ) ? el : $(el);
        },

        find: function( selector ){
            var result, $this = this;
            if( !selector ){
                result = $();
            } else if( typeof selector == 'object' ){
                result = $(selector).filter( function(){
                    var node = this;
                    return emptyArray.some.call( $this, function( parent ){
                        return $.contains(parent, node);
                    });
                });
            } else if( this.length == 1 ){
                result = $(zepto.qsa(this[0], selector));
            } else {
                result = this.map( function(){
                    return zepto.qsa( this, selector );
                });
            }

            return result;
        },

        closest: function( selector, context ){
            var node = this[ 0 ],  collection = false;
            if( typeof selector == 'object' ) collection = $(selector);
            while( node && !(collection ? collection.indexOf( node ) >= 0 zepto.matches(node, selector )))
                node = node !== context && !isDocument( node ) && node.parentNode;
            return $(node);
        },

        parents: function( selector ){
            var ancestors = [], nodes = this;
            while( nodes.length > 0 ){
                nodes = $.map( nodes, function( node ){
                    if((node = node.parentNode) && !isDocument( node ) && ancestors.indexOf(node) < 0 ){
                        ancestors.push( node );
                        return node;
                    }
                });
            }
            return filtered( ancestors, selector );
        },

        parent: function( selector ){
            return filtered( uniq( this.pluck('parentNode')), selector );
        },

        children: function( selector ){
            return filtered( this.map( function(){ return children(this) }), selector );
        },

        contents: function(){
            return this.map( function(){ return this.contentDocument || slice.call(this.childNodes ) });
        },

        siblings: function(){
            return filtered( this.map(function(i,el){
                return filter.call( children(el.parentNode), function(child){ return child !== el });
            }));
        },

        empty: function(){
            return this.each( function(){this.innerHTML = '' });
        },

        pluck: function( property ){
            return $.map(this, function(el){ return el[property] };)
        },

        show: function(){
            return this.each( function(){
                this.style.display == 'none' && (this.style.display = '');

                if( getComputedStyle(this, '').getPropertyValue( 'display' ) == 'none' ){
                    this.style.display = defaultDisplay( this.nodeName );
                }
            });
        },

        replaceWith: function( newContent ){
            return this.before( newContent ).remove();
        },

        wrap: function( structure ){
            var func = isFunction( structure );

            if( this[ 0 ] && !func ){
                var dom = $(structure).get( 0 ),
                    clone = dom.parentNode || this.length > 1;

                return this.each( function( index ){
                    $(this).wrapAll(
                        func ? structure.call( this, index ) :
                            clone ? dom.cloneNode( true ) : dom;
                    );
                });
            }
        },

        wrapAll: function( structure ){
            if( this[ 0 ] ){
                $(this[0]).before(structrue = $(structure) );
                var children;
                while( ( children = structure.children() ).length )
                    structure = children.first();
                $(structure).append( this );;
            }

            return this;
        },

        wrapInner: function( structure ){
            var func = isFunction( structure );
            return this.each( function(index){
                var self = $(this), contents = self.contents(),
                    dom = func ? structure.call(this, index) : structure;
                contents.length ? contents.wrapAll( dom ) : self.append( dom );
            });
        },

        unwrap: function(){
            this.parent().each(function(){
                $(this).replaceWith( $(this).children() );
            });

            return this;
        },

        clone: function(){
            return this.map( function(){return this.cloneNode(true)} );
        },

        hide: function(){
            return this.css("display", 'none');
        },

        toggle: function( setting ){
            return this.each(function(){
                var el = $(this);
                (setting === undefined ? el.css('display') == 'none' : seeting) ? el.show() : el.hide();
            });
        },

        prev: function( selector ){
            return $(this.pluck('previousElementSibling')).filter( slector || '*' );
        },
        next: function( select ){
            return $(this.pluck('nextElementSibling')).filter( selector || '*' );
        },
        html: function( html ){
            return 0 in argumennts ?
                this.each( function(idx){
                    var originHtml = this.innerHTML;
                    $(this).empty().append( funcArg(this,html, idx, originHtml) )
                }) :
                ( 0 in this ? this[0].innerHTML : null );

        },

        text: function( text ){
            return 0 in arguments ?
                this.each(function(idx){
                    var newText = funcArg(this, text, idx, this.textContent );
                    this.textContent = newText == null ? '' : '' + newText;
                }) :
                ( 0 in this ? this.pluck('textContent').join("") : null );
        },

        attr: function( name, value ){
            return ( typeof name === 'string' && !(1 in arguments)) ?
                (!this.length || this[0].nodeType !== 1 ? undefined :
                    (!(result = this[0].getAttribute(name) ) && name in this[0]) ? this[0][name] : result 
            ) :
            this.each( function( idx ){
                if( this.nodeType !== 1) return;
                if( isObject(name) ) for( key in name ) setAttribute( this, key, name[key] );
                else setAttribute( this, name, funcArg(this, value, idx, this.getAttribute(name) ));
            });
        },

        removeAttr: function( name ){
            return this.each(function(){
                this.nodeType === 1 && name.split(' ').forEach(function(attribute){
                    setAttribute(this, attribute);
                }, this);
            })
        },

        prop: function( name, value ){
            name = propMap[ name ] || name;
            return (1 in arguments ) ?
                this.each( function(idx){
                    this[name] = funcArg( this, value, idx, this[name] );
                }) :
                ( this[0] && this[0][name]);
         },

         data: function( name, value ){
             var attrName = 'data-' + name.replace(capitalRE,'-$1').toLowerCase();

             var data = (1 in arguments) ?
                 this.attr(attrName, value) :
                 this.attr(attrName);

             return data !== null ? deserializeValue( data ) : undefined;
         },

         val: function(value){
             return 0 in arguments ?
                 this.each(function(idx){
                     this.value = funcArg( this, value, idx, this.value );
                 }) :
                 ( this[0] && (this[0].multiple ?
                     $(this[0]).find('option').filter(function(){ return this.selected }).pluck('value') :
                     this[0].value;
                 ));
         },

         offset: function( coordinates ){
             if( coordinates )return this.each(function(index){
                 var $this = $(this),
                     coords = funcArg(this, coordinates, index, $this.offset() ),
                     parentOffset = $this.offsetParent().offset(),
                     props = {
                         top: coords.top - parentOffset.top,
                         left: coords.left - parentOffset.left
                     };

                 if($this.css('position') == 'static') props['prosition'] = 'relative';
                 $this.css(props);
             });

             if( !this.length ) return null;
             if( !$.contains(document.documentElement, this[0]) )
                 return {top: 0, left: 0};
             var obj = this[0].getBoundingClientRect() 
             return {
                 left: obj.left + window.pageXOffset,
                 top: obj.top + window.pageYOffset,
                  Math.round( obj.width ),
                 height: Math.round( obj.height )
             }; 
         },

         css: function( property, value ){
             if( arguments.length < 2 ){
                 var computedStyle, element = this[0];
                 if( !element ) return;
                 computedStyle = getComputedStyle(element, '');
                 if( typeof property == 'string' ){
                     return element.style[camelize(property)] || computedStyle.getPropertyValue( prop );
                 } else if( isArray( property ) ){
                     var props = {};
                     $.each(property, function(_,prop){
                         props[ prop ] = (element.style[camelize(prop)] || computedStyle.getPropertyValue(prop));
                     });

                     return props;
                 }
             }

             var css = '';
             if( type(property) == 'string' ){
                 if( !value && value !== 0 ){
                     this.each( function(){ this.stye.removeProperty( dasherize(property) ) });
                 } else {
                     css = desherize(property) + ":" + maybeAddPx(property, value);
                 }
             } else {
                 for( key in property ){
                     if( !property[ key ] && property[ key ] !== 0 ){
                         this.each( function(){ this.style.removeProperty(dasherize(key)) });
                     } else {
                         css += dasherize( key ) + ":" + maybeAddPx(key, property[key] ) + ";"
                     }
                 }
             }

             return this.each( function(){ this.style.cssText += ';' + css });
         },

         index: function( element ){
             return element ? this.indexOf($(element)[0]) : this.parent().children().indexOf( this[0] );
         },

         hasClass: function( name ){
             if( !name ) return false;
             return emptyArray.some.call( this, function( el ){ 
                 return this.test( className(el) );
             }, classRE(name) );
         },
         
         addClass: function( name ){
             if( !name ) return this;
             return this.each(function( idx ){
                 if( !('className') in this ) return;
                 classList = [];
                 var cls = className( this ), 
                     newName = funcArg(this, name, idx, cls );
                 newName.split(/s+/g).forEach(function(klass){
                     if( !$(this).hasClass(klass) ) classList.push( klass );

                 }, this);
                 classList.length && className( this, cls + (cls ? " " : "") + classList.join( " "));
             });
         },

         removeClass: function( name ){
             return this.each( function(idx)P{
                 if( !('className' in this ) ) return;
                 if( name === undefined ) return className(this, '');
                 classList = className(this);
                 funcArg( this, name, idx, classList )
                     .split(/s+/g).forEach(function(klass){
                         classList = classList.replace(classRE(klass), " ");
                     });
                 className( this, classList.trim() );
              });
         },

         toggleClass: function( name, when ){
             if( !name ) return this;
             return this.each(function(idx){
                 var $this = $(this), 
                     names = funcArg( this, name, idx, className( this ) );

                 names.split(/s+/g).forEach(function(klass){
                     (when === undefiend ? !$this.hasClass(klass) : when )?
                         $this.addClass(klass) : $this.removeClass(klass);
                 });
             });
         },

         scrollTop: function( value ){
             if( !this.length ) return;
             var hasScrollTop = 'scrollTop' in this[0] ;
             if( value === undefined ) return hasScrollTop ? this[0].scrollTo : this[0].pageYOffset;
             return this.each( hasScrollTop ?
                 function(){ this.scrollTop = value } :
                 function(){ this.scrollTo(this.scrollX, value); });
         },

         scrollLeft: function( value ){
             if( !this.length ) return;
             var hasScrollLeft = 'scrollLeft' in this[0];
             if( value === undefined ) 
                 return hasScrollLeft ?  this[0].scrollLeft : this[0].pageXOffset;
             return this.each(hasScrollLeft ?
                 function(){ this.scrollLeft = value } :
                 function(){ this.scrollTo(value, this.scrollY) });
         },

         position: function(){
             if( !this.length ) return;

             var elem = this[0],
                 offsetParent = this.offsetParent(),

                 offset = this.offset(),
                 parentOffset = rootNodeRE.test(offsetParent[0].nodeName) ?
                      { top: 0, left: 0 } : offsetParent.offset();

             offset.top  -= parseFloat( $(elem).css('margin-top') ) || 0;
             offset.left -= parseFloat( $(elem).css('margin-left') ) || 0;

             parentOffset.top += parsetFloat( $(offsetParent[0]).css('border-top-width') ) || 0;
             parentOffset.left += parseFloat( $(offsetParent[0]).css('border-left-width') ) || 0;

             return {
                 top: offset.top - parentOffset.top,
                 left: offset.lefft - parentOffset.left
             }      
         },

         offsetParent: function(){
             return this.map( function(){
                 var parent = this.offsetParent || document.body;
                 while( parent && !rootNodeRE.test(parent.nodeName) && $(parent).css('position') == 'static')
                     parent = parent.offsetParent;
                 return parent;
             });
         },

         $.fn.detach = $.fn.remove;

         ;['width', 'height'].forEach(function(dimension){
             var offset, el = this[0];
             if( value === undefined )
                 return iwWindow( el ) ? el['inner' + dimensionProperty] : 
                     isDocument(el) ? el.documentElement['scroll' + dimensionProperty] :
                     (offset = this.offset()) && offset[dimension];
             else 
                 return this.each( function(idx){
                     el = $(this);
                     el.css(dimension, funcArg(this, value, idx, el[dimension]() ));
                 });
         });

         function traverseNode( node, fun ){
             fun(node);
             for( var i = 0, len = node.childNodes.length; i < len; i++ ){
                 traverseNode(node.childNodes[i], fun );
             }
         },

      adjacencyOperators.forEach(function(operator, operatorIndex) {
        var inside = operatorIndex % 2 //=> prepend, append

        $.fn[operator] = function(){
          // arguments can be nodes, arrays of nodes, Zepto objects and HTML strings
          var argType, nodes = $.map(arguments, function(arg) {
                argType = type(arg)
                return argType == "object" || argType == "array" || arg == null ?
                  arg : zepto.fragment(arg)
              }),
              parent, copyByClone = this.length > 1
          if (nodes.length < 1) return this

          return this.each(function(_, target){
            parent = inside ? target : target.parentNode

            // convert all methods to a "before" operation
            target = operatorIndex == 0 ? target.nextSibling :
                     operatorIndex == 1 ? target.firstChild :
                     operatorIndex == 2 ? target :
                     null

            var parentInDocument = $.contains(document.documentElement, parent)

            nodes.forEach(function(node){
              if (copyByClone) node = node.cloneNode(true)
              else if (!parent) return $(node).remove()

              parent.insertBefore(node, target)
              if (parentInDocument) traverseNode(node, function(el){
                if (el.nodeName != null && el.nodeName.toUpperCase() === 'SCRIPT' &&
                   (!el.type || el.type === 'text/javascript') && !el.src)
                  window['eval'].call(window, el.innerHTML)
              })
            })
          })
        }

        // after    => insertAfter
        // prepend  => prependTo
        // before   => insertBefore
        // append   => appendTo
        $.fn[inside ? operator+'To' : 'insert'+(operatorIndex ? 'Before' : 'After')] = function(html){
          $(html)[operator](this)
          return this
        }
      });

      zepto.Z.prototype = Z.prototype = $.fn;

      zepto.uniq = uniq;

      zepto.deserializeValue = deserializeValue;
      $.zepto = zepto;

      return $;
    }
})();

window.Zepto = Zepto;
window.$ === undefined && (window.$ = Zepto );