text: /**
  * Zect v1.2.10
  * (c) 2015 guankaishe
  * Released under the MIT License.
  */
  (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory();
  	else if(typeof define === 'function' && define.amd)
  		define(factory);
  	else if(typeof exports === 'object')
  		exports["Zect"] = factory();
  	else
  		root["Zect"] = factory();
  })(this, function() {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  
  
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(1)
  
  /***/ },
  /* 1 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var $ = __webpack_require__(2)
  	var is = __webpack_require__(3)
  	var Mux = __webpack_require__(4)
  	var util = __webpack_require__(5)
  	var conf = __webpack_require__(6)
  	var execute = __webpack_require__(7)
  	var Compiler = __webpack_require__(8)
  	var Expression = __webpack_require__(9)
  
  	var Directive = Compiler.Directive
  	var AttributeDirective = Compiler.Attribute
  	var TextDirective = Compiler.Text
  	var ElementDirective = Compiler.Element
  
  
  	/**
  	 *  private vars
  	 */
  	var buildInDirts = __webpack_require__(10)(Zect)  // preset directives getter
  	var elements = __webpack_require__(11)(Zect)      // preset directives getter
  	var allDirectives = [buildInDirts, {}]                // [preset, global]
  	var gdirs = allDirectives[1]
  	var gcomps = {}                                 // global define components
  
  	var _isExpr = Expression.isExpr
  	/**
  	 *  Global API
  	 */
  	function Zect(options) {
  	    var insOpt = _mergeMethodMixins([options])
  	    return ViewModel.call(this, insOpt)
  	}
  	Zect.extend = function(options) {
  	    function Class(opt) {
  	        var insOpt = _mergeMethodMixins([options, opt])
  	        /**
  	         *  Prototype inherit
  	         */
  	        return ViewModel.call(this, insOpt)
  	    }
  	    _inherit(Class, Zect)
  	    return Class
  	}
  	Zect.component = function(id, definition) {
  	    var Comp = Zect.extend(definition)
  	    gcomps[id.toLowerCase()] = Comp
  	    return Comp
  	}
  	Zect.directive = function(id, definition) {
  	    gdirs[id] = definition
  	}
  	Zect.namespace = function(ns) {
  	    conf.namespace = ns
  	}
  	Zect.$ = $
  	_inherit(Zect, Compiler)
  
  	/*******************************
  	      ViewModel Constructor
  	*******************************/
  	function ViewModel(options) {
  	    // inherit Compiler
  
  	    var vm = this
  	    var el = options.el
  	    var components = [gcomps, options.components || {}]
  	    var directives = allDirectives.concat([options.directives || {}])
  
  	    var _directives = [] // local refs for all directives instance of the vm    
  	    var _components = [] // local refs for all components    
  	    var NS = conf.namespace
  	    var componentProps = [NS + 'component', NS + 'data', NS + 'methods', NS + 'ref', NS + 'replace']
  	    var $childrens = options.$childrens
  
  	    // set $parent ref
  	    vm.$parent = options.$parent || null
  
  	    /**
  	     *  Mounted element detect
  	     */
  	    if (util.type(el) == 'string') {
  	        el = document.querySelector(el)
  	    } 
  	    if (el && options.template) {
  	        el.innerHTML = options.template
  	    } else if (options.template) {
  	        el = document.createElement('div')
  	        el.innerHTML = options.template
  	    } else if (!is.Element(el)) {
  	        throw new Error('Unmatch el option')
  	    }
  
  	    // replace "$NS-template" of actual instance's DOM  
  	    if (el.children.length == 1 && el.firstElementChild.tagName.toLowerCase() == (NS + 'template')) {
  	        var $holder = el.firstElementChild
  	        var childNodes = _slice($holder.childNodes)
  	        var attributes = _slice($holder.attributes)
  
  	        el.removeChild($holder)
  	        /**
  	         *  Migrate childNodes
  	         */
  	        $(childNodes).appendTo(el)
  	        /**
  	         *  Merge attributes
  	         */
  	        attributes.forEach(function (att) {
  	            var nv
  	            if (att.name == 'class') {
  	                nv = att.value + (el.className 
  	                                    ? ' ' + el.className 
  	                                    : '')
  
  	            } else if (!el.hasAttribute(att.name)) {
  	                nv = att.value
  	            } else {
  	                return
  	            }
  	            el.setAttribute(att.name, nv)
  	        })
  	    }
  	    // content insertion
  	    var points = _slice(el.querySelectorAll('content'))
  	    if (points) {
  	        var $con
  	        if ($childrens && $childrens.length) {
  	            $con = document.createDocumentFragment()
  	            _slice($childrens).forEach(function (n) {
  	                $con.appendChild(n)
  	            })
  	        }
  	        points.forEach(function (p) {
  	            if (!$childrens || !$childrens.length) {
  	                return $(p).remove()
  	            }
  	            var $p = $(p)
  	            var select = $p.attr('select')
  	            var tar
  	            var ind
  
  	            if (select 
  	                && (tar = $con.querySelector(select)) 
  	                && ~(ind = $childrens.indexOf(tar)) ) {
  
  	                $p.replace(tar)
  	                $childrens.splice(ind, 1)
  	            } else if (!select) {
  	                $p.replace($con)
  	                $childrens = null
  	            }
  	        })
  	    }
  
  	    /**
  	     * Replace external component element holder with internal child element
  	     */
  	    if (options.replace) {
  	        if (el.children.length !== 1) {
  	            console.warn('Can\'t using \'' + NS + 'replace=true\' for a component that has no or multiple child-elements.')
  	        } else if (el.parentNode) {
  	            var replacedEl = el.firstElementChild
  	            _cloneArributes(replacedEl, el)
  	            el.parentNode.replaceChild(replacedEl, el)
  	            el = replacedEl
  	        } else {
  	            el = el.firstElementChild
  	        }
  	    }
  
  	    vm.$el = el
  
  	    /**
  	     *  get component define by tagName
  	     */
  	    vm.$component = getComponent
  
  	    /**
  	     *  Component instance refs
  	     */
  	    vm.$refs = {}
  
  	    /**
  	     *  assign methods
  	     */
  	    var methods = {}
  	    util.objEach(options.methods, function(k, v) {
  	        if (util.type(v) !== 'function') return console.warn(k + ' is not a function.')
  	        vm[k] = methods[k] = v.bind(vm)
  	    })
  	    vm.$methods = methods
  
  	    var $data
  	    var dataOpt = {}
  
  	    Object.defineProperty(vm, '$data', {
  	        enumerable: true,
  	        get: function() {
  	            // $data will be undefined in created calling, so using dataOpt as temporary
  	            return $data || dataOpt
  	        },
  	        set: function(v) {
  	            if (!$data) return util.merge(dataOpt, v)
  
  	            $data.$set(v)
  	            return $data
  	        }
  	    })
  	    vm.$set = function () {
  	        $data.$set.apply($data, arguments)
  	    }
  	    vm.$get = function () {
  	        return $data.$get.apply($data, arguments)
  	    }
  	    vm.$watch = function (/*[ keypath ], */fn) {
  	        return $data.$watch.apply($data, arguments)
  	    }
  	    vm.$unwatch = function (/*[ keypath ], */fn) {
  	        return $data.$unwatch.apply($data, arguments)
  	    }
  
  	    var created = options.created
  	    if (options.$data) {
  	        $data = options.$data
  	        // if state model instance passsing, call after set
  	        created && created.call(vm)
  	    } else {
  	        util.merge(dataOpt, _funcOrObject(options, 'data'))
  	        // Call before vm-$data instance
  	        created && created.call(vm)
  	        // Instance observable state model
  	        var mopts = {
  	            props: dataOpt,
  	            computed: options.computed,
  	            computedContext: vm
  	        }
  	        $data = new Mux(mopts)
  	    }
  
  	    /**
  	     *  DOM Compile
  	     *  @TODO the unique interface for a compiled node($el, $remove)
  	     */
  	    vm.$compile = function (el, scope) {
  	        var compiler
  
  	        util.walk(el, function (node) {
  	            var isRoot = node === el
  	            var result = compile(node, scope, isRoot)
  	            if (isRoot) compiler = result.inst
  	            return result.into
  	        })
  	        return compiler
  	    }
  
  	    var beforeDestroy = options.destroy
  	    vm.$destroy = function () {
  	        if (vm.$destroyed) return
  	        beforeDestroy && beforeDestroy.call(vm)
  
  	        ;[_components, _directives].forEach(function (items) {
  	            items.forEach(function (inst) {
  	                inst.$destroy()
  	            })
  	        })
  
  	        $data.$destroy()
  
  	        // instance methods/properties
  	        vm.$el = null
  	        vm.$get = null
  	        vm.$set = null
  	        vm.$refs = null
  	        vm.$watch = null
  	        vm.$unwatch = null
  	        vm.$compile = null
  	        vm.$component = null
  
  	        // private vars
  	        directives = null
  	        components = null
  	        _directives = null
  	        _components = null
  
  	        // marked
  	        vm.$destroyed = true
  	    }
  	    vm.$compiler = vm.$compile(el)
  
  	    /**
  	     *  Call ready after compile
  	     */
  	    options.ready && options.ready.call(vm)
  
  	    function _getAllDirts () {
  	        var _dirts = {}
  	        directives.forEach(function(group) {
  	            util.objEach(group, function(id, def) {
  	                _dirts[NS + id] = def
  	            })
  	        })
  	        return _dirts
  	    }
  	    function _setBindings2Scope (scope, ref) {
  	        scope && scope.bindings && (scope.bindings.push(ref))
  	    }
  	    function compile (node, scope, isRoot) {
  	        /**
  	         *  1. ELEMENT_NODE; 
  	         *  2. ATTRIBUTE_NODE; 
  	         *  3. TEXT_NODE; 
  	         *  8. COMMENT_NODE; 
  	         *  9. DOCUMENT_NODE; 
  	         *  11. DOCUMENT_FRAGMENT;
  	         */
  	        var into = true
  	        var inst
  	        switch (node.nodeType) {
  	            case 1:
  	                /**
  	                 * static block no parsing
  	                 */
  	                if (node.hasAttribute(NS + 'static')) {
  	                    into = false
  	                    break
  	                }
  	                /**
  	                 * convert those $ns-if, $ns-repeat attribute to block element
  	                 */
  	                node = compilePseudoDirectiveElement(node)
  	                /**
  	                 *  scope syntax
  	                 */
  	                if (inst = compileElement(node, scope, isRoot)) {
  	                    into = false
  	                    break
  	                }
  	                /**
  	                 *  Attribute directive
  	                 */
  	                compileDirective(node, scope)
  	                /**
  	                 *  Compile custom-element
  	                 */
  	                if (inst = compileComponent(node, vm, scope, isRoot)) {
  	                    into = false
  	                    break
  	                }
  	                break
  	            case 3:
  	                // ignore whitespace
  	                if (node.nodeValue.trim()) inst = compileText(node, vm, scope, isRoot)
  	                into = false
  	                break
  	            case 11:
  	                // document fragment
  	                break
  	            default:
  	                into = false
  	        }
  	        return {
  	            into: !!into,
  	            inst: !inst && isRoot ? new Compiler(node) : inst
  	        }
  	    }
  
  	    function compilePseudoDirectiveElement (node) {
  	        var repeatAttName = NS + 'repeat'
  	        var ifAttName = NS + 'if'
  	        var valueAttName
  	        var matchedAttName
  
  	        if (node.hasAttribute(ifAttName)) {
  	            matchedAttName = ifAttName
  	            valueAttName = 'is'
  	        } else if (node.hasAttribute(repeatAttName)) {
  	            matchedAttName = repeatAttName
  	            valueAttName = 'items'
  	        } else {
  	            return node
  	        }
  	        var attValue = node.getAttribute(matchedAttName)
  	        var blockNode = document.createElement(matchedAttName)
  	        node.removeAttribute(matchedAttName)
  	        node.parentNode && node.parentNode.replaceChild(blockNode, node)
  	        blockNode.appendChild(node)
  	        blockNode.setAttribute(valueAttName, attValue)
  
  	        while(node.hasAttribute(ifAttName) || node.hasAttribute(repeatAttName)) {
  	            compilePseudoDirectiveElement(node)
  	        }
  	        return blockNode
  	    }
  
  	    /**
  	     *  Reverse component Constructor by tagName
  	     */
  	    function getComponent(tn) {
  	        var cid = tn.toLowerCase()
  	        var compDef
  	        components.some(function (comp) {
  	            if (comp.hasOwnProperty(cid)) {
  	                compDef = comp[cid]
  	                return true
  	            }
  	        })
  	        return compDef
  	    }
  	    /**
  	     *  Compile element for block syntax handling
  	     */
  	    function compileElement(node, scope, isRoot) {
  	        var tagName = node.tagName
  	        switch(true) {
  	            /**
  	             *  <*-if></*-if>
  	             */
  	            case is.IfElement(tagName):
  	                var inst = new ElementDirective(
  	                        vm, 
  	                        scope,
  	                        node, 
  	                        elements['if'], 
  	                        NS + 'if', 
  	                        $(node).attr('is')
  	                )
  	                if (!isRoot) {
  	                    inst.$mount(node)
  	                }
  	                // save elements refs
  	                _directives.push(inst)
  	                // save bindins to scope
  	                _setBindings2Scope(scope, inst)
  	                return inst
  	            /**
  	             *  <*-repeat></*-repeat>
  	             */
  	            case is.RepeatElement(tagName):
  	                var inst = new ElementDirective(
  	                        vm, 
  	                        scope,
  	                        node, 
  	                        elements['repeat'],
  	                        NS + 'repeat', 
  	                        $(node).attr('items')
  	                )
  	                if (!isRoot) {
  	                    inst.$mount(node)
  	                }
  	                _directives.push(inst)
  	                _setBindings2Scope(scope, inst)
  	                return inst
  	        }
  	    }
  
  	    /**
  	     *  comment
  	     */
  	    function compileComponent (node, parentVM, scope) {
  	        var cAttName = NS + 'component'
  	        var CompName = node.getAttribute(cAttName)
  	        var tagName = node.tagName
  	        // filtrate most no-compoment element
  	        if (!CompName && (tagName == 'DIV' || tagName == 'SPAN' || tagName == 'A' || tagName == 'IMG')) return
  	        CompName = CompName || tagName
  	        var Comp = getComponent(CompName)
  
  	        /**
  	         *  Tag is not a custom component element
  	         */
  	        if (!Comp) return
  	        var $node = $(node)
  	        $node.removeAttr(cAttName)
  
  	        // don't need deep into self
  	        if (node === parentVM.$el) return
  	        // suport expression, TBD
  	        var refName = NS + 'ref'
  	        var dAttName = NS + 'data'
  	        var mAttName = NS + 'methods'
  	        var rAttName = NS + 'replace'
  
  	        var ref = $node.attr(refName)
  	        var dataExpr = $node.attr(dAttName)
  	        var methods = $node.attr(mAttName)
  	        var replace = $node.attr(rAttName)
  
  	        $node.removeAttr(refName)
  	             .removeAttr(dAttName)
  	             .removeAttr(mAttName)
  	             .removeAttr(rAttName)
  
  	        var _isDataExpr = _isExpr(dataExpr)
  	        var bindingData
  	        var bindingMethods
  	        /**
  	         *  Watch
  	         */
  	        var execLiteral = Expression.execLiteral
  	        var ast = {}
  	        var revealAst = {}
  	        var compVM
  
  	        function _parseExpr (expr) {
  	            var name
  	            var expr = expr.replace(/^[^:]+:/, function (m) {
  	                            name = m.replace(/:$/, '').trim()
  	                            return ''
  	                        }).trim()
  	            return {
  	                name: name,
  	                expr: expr,
  	                vars: Expression.extract(expr)
  	            }
  	        }
  	        function _setBindingObj (expr) {
  	            var r = _parseExpr(expr)
  	            ast[r.name] = r
  	            ;(r.vars || []).forEach(function (v) {
  	                ;!revealAst[v] && (revealAst[v] = [])
  	                ;!~revealAst[v].indexOf(r.name) && revealAst[v].push(r.name)
  	            })
  	        }
  
  	        var bindingData = execLiteral(dataExpr, parentVM, scope)
  	        var bindingMethods = execLiteral(methods, parentVM, scope) // --> bindingMethods
  	        
  	        compVM = new Comp({
  	            el: node,
  	            data: bindingData,
  	            methods: bindingMethods,
  	            $parent: parentVM,
  	            $childrens: _slice(node.childNodes),
  	            replace: replace == 'true'
  	        })
  
  	        var plainDataExpr = _isDataExpr ? Expression.strip(dataExpr) : ''
  	        var sep = Expression.sep
  
  	        if (plainDataExpr) {
  	            if (plainDataExpr.match(sep)) {
  	                plainDataExpr.replace(new RegExp(sep + '\\s*$'), '') // trim last seperator
  	                       .split(sep)
  	                       .forEach(_setBindingObj)
  	            } else {
  	                _setBindingObj(plainDataExpr)
  	            }
  	        }
  	        // watch and binding
  	        if (_isDataExpr) {
  	            parentVM.$data.$watch(function (keyPath) {
  	                var nextState
  	                util.objEach(revealAst, function (varName, bindingNames) {
  	                    if (keyPath.indexOf(varName) === 0) {
  	                        ;!nextState && (nextState = {})
  	                        bindingNames.forEach(function (n) {
  	                            nextState[n] = execute(parentVM, scope, ast[n].expr)
  	                        })
  	                    }
  	                })
  	                nextState && compVM.$set(nextState)
  	            })
  	        }
  	        // set ref to parentVM
  	        ref && (parentVM.$refs[ref] = compVM)
  
  	        _components.push(compVM)
  	        _setBindings2Scope(scope, compVM)
  	        // TBM -- to be modify, instance method should not be attached here
  	        compVM.$update = function () {
  	            _isDataExpr && compVM.$set(execLiteral(dataExpr, parentVM, scope))
  	        }
  	        return compVM
  	    }
  	    /**
  	     *  Compile attributes to directive
  	     */
  	    function compileDirective (node, scope) {
  	        var ast = {
  	                attrs: {},
  	                dires: {}
  	            }
  	        var dirtDefs = _getAllDirts()
  	        /**
  	         *  attributes walk
  	         */
  	        _slice(node.attributes).forEach(function(att) {
  	            var aname = att.name
  	            var v = att.value
  	            // parse att
  	            if (~componentProps.indexOf(aname)) {
  	                return
  	            } else if (_isExpr(aname)) {
  	                // variable attribute name
  	                ast.attrs[aname] = v
  	            } else if (aname.indexOf(NS) === 0) {
  	                var def = dirtDefs[aname]
  	                if (def) {
  	                    // directive
  	                    ast.dires[aname] = {
  	                        def: def,
  	                        expr: v
  	                    }
  	                } else {
  	                    return
  	                }
  	            } else if (_isExpr(v.trim())) {
  	                // named attribute with expression
  	                ast.attrs[aname] = v
  	            } else {
  	                return
  	            }
  	            node.removeAttribute(aname)
  	        })
  
  	        /**
  	         *  Attributes binding
  	         */
  	        util.objEach(ast.attrs, function(name, value) {
  	            var attd = new AttributeDirective(vm, scope, node, name, value)
  	            _directives.push(attd)
  	            _setBindings2Scope(scope, attd)
  	        })
  
  	        /**
  	         *  Directives binding
  	         */
  	        util.objEach(ast.dires, function(dname, spec) {
  	            var def = spec.def
  	            var expr = spec.expr
  	            var sep = ';'
  	            var d
  	            // multiple defines expression parse
  	            if (def.multi && expr.match(sep)) {
  	                Expression.strip(expr)
  	                        .split(sep)
  	                        .forEach(function(item) {
  	                            // discard empty expression 
  	                            if (!item.trim()) return
  	                            
  	                            d = new Directive(vm, scope, node, def, dname, '{' + item + '}')
  	                            _directives.push(d)
  	                            _setBindings2Scope(scope, d)
  	                        })
  	            } else {
  	                d = new Directive(vm, scope, node, def, dname, expr)
  	                _directives.push(d)
  	                _setBindings2Scope(scope, d)
  	            }
  	        })
  	    }
  
  	    function compileText (node, vm, scope) {
  	        var originExpr = node.nodeValue
  	        var v = Expression.veil(originExpr)
  	        var exprReg = Expression.exprRegexp
  
  	        var parts = v.split(exprReg)
  	        var exprs = v.match(exprReg)
  
  	        var inst
  	        // expression match or not
  	        if (exprs && exprs.length) {
  	            inst = new TextDirective(vm, scope, node, originExpr, parts, exprs)
  	            _directives.push(inst)
  	            _setBindings2Scope(scope, inst)
  	        }
  	        return inst
  	    }
  	}
  
  	/**
  	 *  private functions
  	 */
  	function _slice (obj) {
  	    if (!obj) return []
  	    return [].slice.call(obj)
  	}
  	function _funcOrObject(obj, prop) {
  	    var tar = obj[prop]
  	    return util.type(tar) == 'function' ? tar.call(obj):tar
  	}
  	function _extend (args) {
  	    return util.extend.apply(util, args)
  	}
  	function _inherit (Ctor, Parent) {
  	    var proto = Ctor.prototype
  	    Ctor.prototype = Object.create(Parent.prototype)
  	    return proto
  	}
  	function _mergeOptions (opts) {
  	    var dest = {}
  	    _extend([dest].concat(opts))
  	    ;['data', 'methods', 'directives', 'components'].forEach(function (prop) {
  	        dest[prop] = _extend([{}].concat(opts.map(function (opt) {
  	            return _funcOrObject(opt, prop)
  	        })))
  	    })
  	    return dest
  	}
  	function _mergeMethodMixins (optMixins) {
  	    var mixins = []
  	    /**
  	     *  Merge option mixins
  	     */
  	    optMixins.forEach(function (o) {
  	        if (o) {
  	            mixins.push(o)
  	            o.mixins && (mixins = mixins.concat(o.mixins))
  	        }
  	    })
  	    var insOpt = _mergeOptions(mixins)
  	    /**
  	     *  Merge method mixins
  	     */
  	    var m = insOpt.methods = insOpt.methods || {}
  	    optMixins.forEach(function (o) {
  	        var mxs = o && o.methods && o.methods.mixins
  	        if (mxs) {
  	            mxs.forEach(function (mx) {
  	                util.objEach(mx, function (k, v) {
  	                    if (k !== 'mixins') m[k] = v
  	                })
  	            })
  	        }
  	    })
  	    delete insOpt.methods.mixins
  	    return insOpt
  	}
  	function _cloneArributes(el, target) {
  	    var $tar = $(target)
  	    _slice(el.attributes).forEach(function (att) {
  	        if (att.name == 'class') $tar.addClass(att.value)
  	        else $tar.attr(att.name, att.value)
  	    })
  	    return target
  	}
  
  	module.exports = Zect
  
  
  /***/ },
  /* 2 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 *  DOM manipulations
  	 */
  
  	'use strict';
  	var util = __webpack_require__(5)
  	var is = __webpack_require__(3)
  
  	function Selector(sel) {
  	    if (util.type(sel) == 'string') {
  	        return Shell(util.copyArray(document.querySelectorAll(sel)))
  	    }
  	    else if (util.type(sel) == 'array') {
  	        return Shell(sel)
  	    }
  	    else if (sel instanceof Shell) return sel
  	    else if (is.DOM(sel)) {
  	        return Shell(new ElementArray(sel))
  	    }
  	    else {
  	        throw new Error('Unexpect selector !')
  	    }
  	}
  
  	function Shell(nodes) {
  	    if (nodes instanceof Shell) return nodes
  	    var $items = new ElementArray()
  	    nodes.forEach(function (item) {
  	        $items.push(item)
  	    })
  	    return $items
  	}
  
  	function ElementArray () {
  	    this.push = function () {
  	        Array.prototype.push.apply(this, arguments)
  	    }
  	    this.forEach = function () {
  	        Array.prototype.forEach.apply(this, arguments)
  	    }
  	    this.push.apply(this, arguments)
  	}
  
  	ElementArray.prototype = Object.create(Shell.prototype)
  
  	var proto = Shell.prototype
  	proto.find = function(sel) {
  	    var subs = []
  	    this.forEach(function(n) {
  	        subs = subs.concat(util.copyArray(n.querySelectorAll(sel)))
  	    })
  	    return Shell(subs)
  	}
  	proto.attr = function(attname, attvalue) {
  	    var len = arguments.length
  	    var el = this[0]
  
  	    if (len > 1) {
  	        el.setAttribute(attname, attvalue)
  	    } else if (len == 1) {
  	        return (el.getAttribute(attname) || '').toString()
  	    }
  	    return this
  	}
  	proto.removeAttr = function(attname) {
  	    this.forEach(function(el) {
  	        el.removeAttribute(attname)
  	    })
  	    return this
  	}
  	proto.addClass = function(clazz) {
  	    this.forEach(function(el) {
  
  	        // IE9 below not support classList
  	        // el.classList.add(clazz)
  
  	        var classList = el.className.split(' ')
  	        if (!~classList.indexOf(clazz)) classList.push(clazz)
  	        el.className = classList.join(' ')
  	    })
  	    return this
  	}
  	proto.removeClass = function(clazz) {
  	    this.forEach(function(el) {
  	        
  	        // IE9 below not support classList
  	        // el.classList.remove(clazz)
  
  	        var classList = el.className.split(' ')
  	        var index = classList.indexOf(clazz)
  	        if (~index) classList.splice(index, 1)
  	        el.className = classList.join(' ')
  	    })
  	    return this
  	}
  	proto.each = function(fn) {
  	    this.forEach(fn)
  	    return this
  	}
  	proto.on = function(type, listener, capture) {
  	    this.forEach(function(el) {
  	        el.addEventListener(type, listener, capture)
  	    })
  	    return this
  	}
  	proto.off = function(type, listener) {
  	    this.forEach(function(el) {
  	        el.removeEventListener(type, listener)
  	    })
  	    return this
  	}
  	proto.html = function(html) {
  	    var len = arguments.length
  	    if (len >= 1) {
  	        this.forEach(function(el) {
  	            el.innerHTML = html
  	        })
  	    } else if (this.length) {
  	        return this[0].innerHTML
  	    }
  	    return this
  	}
  	proto.parent = function() {
  	    if (!this.length) return null
  	    return Shell([_parentNode(this[0])])
  	}
  	proto.remove = function() {
  	    this.forEach(function(el) {
  	        var parent = _parentNode(el)
  	        parent && parent.removeChild(el)
  	    })
  	    return this
  	}
  	proto.insertBefore = function (pos) {
  	    var tar
  	    if (!this.length) return this
  	    else if (this.length == 1) {
  	        tar = this[0]
  	    } else {
  	        tar = _createDocumentFragment()
  	        this.forEach(function (el) {
  	            _appendChild(tar, el)
  	        })
  	    }
  	    _parentNode(pos).insertBefore(tar, pos)
  	    return this
  	}
  	proto.insertAfter = function (pos) {
  	    var tar
  	    if (!this.length) return this
  	    else if (this.length == 1) {
  	        tar = this[0]
  	    } else {
  	        tar = _createDocumentFragment()
  	        this.forEach(function (el) {
  	            _appendChild(tar, el)
  	        })
  	    }
  	    _parentNode(pos).insertBefore(tar, pos.nextSibling)
  	    return this
  	}
  	// return element by index
  	proto.get = function(i) {
  	    return this[i]
  	}
  	proto.append = function(n) {
  	    if (this.length) _appendChild(this[0], n)
  	    return this
  	}
  	proto.appendTo = function (p) {
  	    if (this.length == 1) _appendChild(p, this[0])
  	    else if (this.length > 1) {
  	        var f = _createDocumentFragment()
  	        this.forEach(function (n) {
  	            _appendChild(f, n)
  	        })
  	        _appendChild(p, f)
  	    }
  	}
  	proto.replace = function(n) {
  	    var tar = this[0]
  	    _parentNode(tar).replaceChild(n, tar)
  	    return this
  	}
  
  	function _parentNode (e) {
  	    return e && e.parentNode
  	}
  
  	function _createDocumentFragment () {
  	    return document.createDocumentFragment()
  	}
  
  	function _appendChild (p, c) {
  	    return p.appendChild(c)
  	}
  	module.exports = Selector
  
  
  /***/ },
  /* 3 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	var conf = __webpack_require__(6)
  	module.exports = {
  	    Element: function(el) {
  	        // 1: ELEMENT_NODE, 11: DOCUMENT_FRAGMENT_NODE
  	        return el.nodeType == 1 || el.nodeType == 11
  	    },
  	    DOM: function (el) {
  	        // 8: COMMENT_NODE
  	        return this.Element(el) || el.nodeType == 8
  	    },
  	    IfElement: function(tn) {
  	        return tn == (conf.namespace + 'if').toUpperCase()
  	    },
  	    RepeatElement: function(tn) {
  	        return tn == (conf.namespace + 'repeat').toUpperCase()
  	    }
  	}
  
  /***/ },
  /* 4 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	* Mux.js v2.4.14
  	* (c) 2014 guankaishe
  	* Released under the MIT License.
  	*/
  	(function webpackUniversalModuleDefinition(root, factory) {
  		if(true)
  			module.exports = factory();
  		else if(typeof define === 'function' && define.amd)
  			define(factory);
  		else if(typeof exports === 'object')
  			exports["Mux"] = factory();
  		else
  			root["Mux"] = factory();
  	})(this, function() {
  	return /******/ (function(modules) { // webpackBootstrap
  	/******/ 	// The module cache
  	/******/ 	var installedModules = {};
  
  	/******/ 	// The require function
  	/******/ 	function __webpack_require__(moduleId) {
  
  	/******/ 		// Check if module is in cache
  	/******/ 		if(installedModules[moduleId])
  	/******/ 			return installedModules[moduleId].exports;
  
  	/******/ 		// Create a new module (and put it into the cache)
  	/******/ 		var module = installedModules[moduleId] = {
  	/******/ 			exports: {},
  	/******/ 			id: moduleId,
  	/******/ 			loaded: false
  	/******/ 		};
  
  	/******/ 		// Execute the module function
  	/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
  	/******/ 		// Flag the module as loaded
  	/******/ 		module.loaded = true;
  
  	/******/ 		// Return the exports of the module
  	/******/ 		return module.exports;
  	/******/ 	}
  
  
  	/******/ 	// expose the modules object (__webpack_modules__)
  	/******/ 	__webpack_require__.m = modules;
  
  	/******/ 	// expose the module cache
  	/******/ 	__webpack_require__.c = installedModules;
  
  	/******/ 	// __webpack_public_path__
  	/******/ 	__webpack_require__.p = "";
  
  	/******/ 	// Load entry module and return exports
  	/******/ 	return __webpack_require__(0);
  	/******/ })
  	/************************************************************************/
  	/******/ ([
  	/* 0 */
  	/***/ function(module, exports, __webpack_require__) {
  
  		'use strict';
  
  		module.exports = __webpack_require__(1)
  
  
  	/***/ },
  	/* 1 */
  	/***/ function(module, exports, __webpack_require__) {
  
  		'use strict';
  
  		/**
  		 *  External module's name startof "$"
  		 */
  		var $Message = __webpack_require__(2)
  		var $keypath = __webpack_require__(3)
  		var $arrayHook = __webpack_require__(4)
  		var $info = __webpack_require__(5)
  		var $util = __webpack_require__(6)
  		var $normalize = $keypath.normalize
  		var $join = $keypath.join
  		var $type = $util.type
  		var $indexOf = $util.indexOf
  		var $hasOwn = $util.hasOwn
  		var $warn = $info.warn
  
  		/**
  		 *  CONTS
  		 */
  		var STRING = 'string'
  		var ARRAY = 'array'
  		var OBJECT = 'object'
  		var FUNCTION = 'function'
  		var CHANGE_EVENT = 'change'
  
  		var _id = 0
  		function allotId() {
  		    return _id ++
  		}
  
  		/**
  		 *  Mux model constructor
  		 *  @public
  		 */
  		function Mux(options) {
  		    // static config checking
  		    options = options || {}
  		    Ctor.call(this, options)
  		}
  
  		/**
  		 *  Mux model creator 
  		 *  @public
  		 */
  		Mux.extend = function(options) {
  		    return MuxFactory(options || {})
  		}
  
  		/**
  		 *  Mux global config
  		 *  @param conf <Object>
  		 */
  		Mux.config = function (conf) {
  		    if (conf.warn === false) $info.disable()
  		    else $info.enable()
  		}
  
  		/**
  		 *  Create a emitter instance
  		 *  @param `Optional` context use for binding "this"
  		 */
  		Mux.emitter = function (context) {
  		    return new $Message(context)
  		}
  
  		/**
  		 *  Expose Keypath API
  		 */
  		Mux.keyPath = $keypath
  		Mux.utils = $util
  
  		/**
  		 *  Mux model factory
  		 *  @private
  		 */
  		function MuxFactory(options) {
  
  		    function Class (receiveProps) {
  		        Ctor.call(this, options, receiveProps)
  		    }
  		    Class.prototype = Object.create(Mux.prototype)
  		    return Class
  		}
  		/**
  		 *  Mux's model class, could instance with "new" operator or call it directly.
  		 *  @param receiveProps <Object> initial props set to model which will no trigger change event.
  		 */
  		function Ctor(options, receiveProps) {
  		    var model = this
  		    var emitter = options.emitter || new $Message(model) // EventEmitter of this model, context bind to model
  		    var _emitter = options._emitter || new $Message(model)
  		    var _computedCtx = $hasOwn(options, 'computedContext') ? options.computedContext : model
  		    var __kp__ = options.__kp__
  		    var __muxid__ = allotId()
  		    var _isExternalEmitter =  !!options.emitter
  		    var _isExternalPrivateEmitter =  !!options._emitter
  		    var _destroy // interanl destroyed flag
  		    var _privateProperties = {}
  
  		    _defPrivateProperty('__muxid__', __muxid__)
  		    _defPrivateProperty('__kp__', __kp__)
  		    /**
  		     *  return current keypath prefix of this model
  		     */
  		    function _rootPath () {
  		        return __kp__ || ''
  		    }
  
  		    /**
  		     *  define priavate property of the instance object
  		     */
  		    function _defPrivateProperty(name, value) {
  		        if (instanceOf(value, Function)) value = value.bind(model)
  		        _privateProperties[name] = value
  		        $util.def(model, name, {
  		            enumerable: false,
  		            value: value
  		        })
  		    }
  
  		    var getter = options.props
  
  		    /**
  		     *  Get initial props from options
  		     */
  		    var _initialProps = {}
  		    var _t = $type(getter)
  		    if (_t == FUNCTION) {
  		        _initialProps = getter()
  		    } else if (_t == OBJECT) {
  		        _initialProps = getter
  		    }
  		    // free
  		    getter = null
  
  		    var _initialComputedProps = options.computed
  		    var _computedProps = {}
  		    var _computedKeys = []
  		    var _cptDepsMapping = {} // mapping: deps --> props
  		    var _cptCaches = {} // computed properties caches
  		    var _observableKeys = []
  		    var _props = {} // all observable properties {propname: propvalue}
  
  		    /**
  		     *  Observe initial properties
  		     */
  		    $util.objEach(_initialProps, function (pn, pv) {
  		        _$add(pn, pv, true)
  		    })
  		    _initialProps = null
  
  		    /**
  		     *  Define initial computed properties
  		     */
  		    $util.objEach(_initialComputedProps, function (pn, def) {
  		        _$computed(pn, def.deps, def.get, def.set, def.enum)
  		    })
  		    _initialComputedProps = null
  
  
  		    /**
  		     *  batch emit computed property change
  		     */
  		    _emitter.on(CHANGE_EVENT, function (kp) {
  		        var willComputedProps = []
  		        var mappings = []
  
  		        if (!Object.keys(_cptDepsMapping).length) return
  
  		        while(kp) {
  		            _cptDepsMapping[kp] && (mappings = mappings.concat(_cptDepsMapping[kp]))
  		            kp = $keypath.digest(kp)
  		        }
  
  		        if (!mappings.length) return
  		        /**
  		         *  get all computed props that depend on kp
  		         */
  		        mappings.reduce(function (pv, cv) {
  		            if (!$indexOf(pv, cv)) pv.push(cv)
  		            return pv
  		        }, willComputedProps)
  
  		        willComputedProps.forEach(function (ck) {
  		            $util.patch(_cptCaches, ck, {})
  
  		            var cache = _cptCaches[ck]
  		            var pre = cache.pre = cache.cur
  		            var next = cache.cur = (_computedProps[ck].get || NOOP).call(_computedCtx, model)
  		            if ($util.diff(next, pre)) _emitChange(ck, next, pre)
  		        })
  		    }, __muxid__/*scope*/)
  
  
  		    /**
  		     *  private methods
  		     */
  		    function _destroyNotice () {
  		        $warn('Instance already has bean destroyed')
  		        return _destroy
  		    }
  		    //  local proxy for EventEmitter
  		    function _emitChange(propname/*, arg1, ..., argX*/) {
  		        var args = arguments
  		        var kp = $normalize($join(_rootPath(), propname))
  		        args[0] = CHANGE_EVENT + ':' + kp
  		        _emitter.emit(CHANGE_EVENT, kp)
  		        emitter.emit.apply(emitter, args)
  
  		        args = $util.copyArray(args)
  		        args[0] = kp
  		        args.unshift('*')
  		        emitter.emit.apply(emitter, args)
  		    }
  		    /**
  		     *  Add dependence to "_cptDepsMapping"
  		     *  @param propname <String> property name
  		     *  @param dep <String> dependency name
  		     */
  		    function _prop2CptDepsMapping (propname, dep) {
  		        // if ($indexOf(_computedKeys, dep))
  		        //    return $warn('Dependency should not computed property')
  		        $util.patch(_cptDepsMapping, dep, [])
  
  		        var dest = _cptDepsMapping[dep]
  		        if ($indexOf(dest, propname)) return
  		        dest.push(propname)
  		    }
  		    /**
  		     *  Instance or reuse a sub-mux-instance with specified keyPath and emitter
  		     *  @param target <Object> instance target, it could be a Mux instance
  		     *  @param props <Object> property value that has been walked
  		     *  @param kp <String> keyPath of target, use to diff instance keyPath changes or instance with the keyPath
  		     */
  		    function _subInstance (target, props, kp) {
  
  		        var ins
  		        var _mux = target.__mux__
  		        if (_mux && _mux.__kp__ === kp && _mux.__root__ === __muxid__) {
  		            // reuse
  		            ins = target
  		            // emitter proxy
  		            ins._$emitter(emitter)
  		            // a private emitter for communication between instances
  		            ins._$_emitter(_emitter)
  		        } else {
  		            ins = new Mux({
  		                props: props,
  		                emitter: emitter, 
  		                _emitter: _emitter,
  		                __kp__: kp
  		            })
  		        }
  		        if (!ins.__root__) {
  		            $util.def(ins, '__root__', {
  		                enumerable: false,
  		                value: __muxid__
  		            })
  		        }
  		        return ins
  		    }
  
  		    /**
  		     *  A hook method for setting value to "_props"
  		     *  @param name <String> property name
  		     *  @param value
  		     *  @param mountedPath <String> property's value mouted path
  		     */
  		    function _walk (name, value, mountedPath) {
  		        var tov = $type(value) // type of value
  		        // initial path prefix is root path
  		        var kp = mountedPath ? mountedPath : $join(_rootPath(), name)
  		        /**
  		         *  Array methods hook
  		         */
  		        if (tov == ARRAY) {
  		            $arrayHook(value, function (self, methodName, nativeMethod, args) {
  		                var pv = $util.copyArray(self)
  		                var result = nativeMethod.apply(self, args)
  		                // set value directly after walk
  		                _props[name] = _walk(name, self, kp)
  		                if (methodName == 'splice') {
  		                    _emitChange(kp, self, pv, methodName, args)
  		                } else {
  		                    _emitChange(kp, self, pv, methodName)
  		                }
  		                return result
  		            })
  		        }
  
  		        // deep observe into each property value
  		        switch(tov) {
  		            case OBJECT: 
  		                // walk deep into object items
  		                var props = {}
  		                var obj = value
  		                if (instanceOf(value, Mux)) obj = value.$props()
  		                $util.objEach(obj, function (k, v) {
  		                    props[k] = _walk(k, v, $join(kp, k))
  		                })
  		                return _subInstance(value, props, kp)
  		            case ARRAY:
  		                // walk deep into array items
  		                value.forEach(function (item, index) {
  		                    value[index] = _walk(index, item, $join(kp, index))
  		                })
  		                return value
  		            default: 
  		                return value
  		        }
  		    }
  
  		    /*************************************************************
  		            Function name start of "_$" are expose methods
  		    *************************************************************/
  		    /**
  		     *  Set key-value pair to private model's property-object
  		     *  @param kp <String> keyPath
  		     *  @return <Object> diff object
  		     */
  		    function _$sync(kp, value) {
  		        var parts = $normalize(kp).split('.')
  		        var prop = parts[0]
  
  		        if ($indexOf(_computedKeys, prop)) {
  		            // since Mux@2.4.0 computed property support setter
  		            model[prop] = value
  		            return false
  		        }
  		        if (!$indexOf(_observableKeys, prop)) {
  		            $warn('Property "' + prop + '" has not been observed')
  		            // return false means sync prop fail
  		            return false
  		        }
  
  		        var pv = $keypath.get(_props, kp)
  		        var isObj = instanceOf(value, Object)
  		        var nKeypath = parts.join('.')
  		        var name = parts.pop()
  		        var parentPath = parts.join('.')
  		        var parent = $keypath.get(_props, parentPath)
  		        var isParentObserved = instanceOf(parent, Mux)
  
  		        if (isParentObserved) {
  		            if ($hasOwn(parent, name)) {
  		                parent.$set(name, value)
  		            } else {
  		                parent.$add(name, value)
  		            }
  		        } else {
  		            $keypath.set(
  		                _props, 
  		                kp, 
  		                isObj
  		                    ? _walk(name, value, $join(_rootPath(), nKeypath))
  		                    : value
  		            )
  		            if ($util.diff(value, pv)) {
  		                _emitChange(kp, value, pv)
  		            }
  		        }
  
  		    }
  
  		    /**
  		     *  sync props value and trigger change event
  		     *  @param kp <String> keyPath
  		     */
  		    function _$set(kp, value) {
  		        if (_destroy) return _destroyNotice()
  
  		        _$sync(kp, value)
  		        // if (!diff) return
  		        /**
  		         *  Base type change of object type will be trigger change event
  		         *  next and pre value are not keypath value but property value
  		         */
  		        // if ( kp == diff.mounted && $util.diff(diff.next, diff.pre) ) {
  		        //     var propname = diff.mounted
  		        //     // emit change immediately
  		        //     _emitChange(propname, diff.next, diff.pre)
  		        // }
  		    }
  
  		    /**
  		     *  sync props's value in batch and trigger change event
  		     *  @param keyMap <Object> properties object
  		     */
  		    function _$setMulti(keyMap) {
  		        if (_destroy) return _destroyNotice()
  
  		        if (!keyMap || $type(keyMap) != OBJECT) return
  		        $util.objEach(keyMap, function (key, item) {
  		            _$set(key, item)
  		        })
  		    }
  
  		    /**
  		     *  create a prop observer
  		     *  @param prop <String> property name
  		     *  @param value property value
  		     */
  		    function _$add(prop, value, silence) {
  		        if (prop.match(/[\.\[\]]/)) {
  		            throw new Error('Propname shoudn\'t contains "." or "[" or "]"')
  		        }
  
  		        if ($indexOf(_observableKeys, prop)) {
  		            // If value is specified, reset value
  		            return arguments.length > 1 ? true : false
  		        }
  		        _props[prop] = _walk(prop, $util.copyValue(value))
  		        _observableKeys.push(prop)
  		        $util.def(model, prop, {
  		            enumerable: true,
  		            get: function() {
  		                return _props[prop]
  		            },
  		            set: function (v) {
  		                _$set(prop, v)
  		            }
  		        })
  		        // add peroperty will trigger change event
  		        !silence && _emitChange(prop, value)
  		    }
  
  		    /**
  		     *  define computed prop/props of this model
  		     *  @param propname <String> property name
  		     *  @param deps <Array> computed property dependencies
  		     *  @param fn <Function> computed property getter
  		     *  @param enumerable <Boolean> whether property enumerable or not
  		     */
  		    function _$computed (propname, deps, getFn, setFn, enumerable) {
  		        /**
  		         *  property is exist
  		         */
  		        if ($indexOf(_computedKeys, propname)) return
  
  		        _computedKeys.push(propname)
  		        _computedProps[propname] = {
  		            'deps': deps, 
  		            'get': getFn,
  		            'set': setFn
  		        }
  
  		        /**
  		         *  Add to dependence-property mapping
  		         */
  		        ;(deps || []).forEach(function (dep) {
  		            while(dep) {
  		                _prop2CptDepsMapping(propname, dep)
  		                dep = $keypath.digest(dep)
  		            }
  		        })
  		        /**
  		         *  define getter
  		         */
  		        $util.patch(_cptCaches, propname, {})
  		        var dest = _cptCaches[propname]
  		        dest.cur = getFn ? getFn.call(_computedCtx, model):undefined
  
  		        $util.def(model, propname, {
  		            enumerable: enumerable === undefined ? true : !!enumerable,
  		            get: function () {
  		                return dest.cur
  		            },
  		            set: function () {
  		                setFn && setFn.apply(_computedCtx, arguments)
  		            }
  		        })
  		        // emit change event when define
  		        _emitChange(propname, dest.cur)
  		    }
  
  		    /*******************************
  		               define instantiation's methods
  		     *******************************/
  		    /**
  		     *  define observerable prop/props
  		     *  @param propname <String> | <Array>
  		     *  @param defaultValue Optional
  		     *  ----------------------------
  		     *  @param propnameArray <Array>
  		     *  ------------------------
  		     *  @param propsObj <Object>
  		     */
  		    _defPrivateProperty('$add', function(/* [propname [, defaultValue]] | propnameArray | propsObj */) {
  		        var args = arguments
  		        var first = args[0]
  		        var pn, pv
  
  		        switch($type(first)) {
  		            case STRING:
  		                // with specified value or not
  		                pn = first
  		                if (args.length > 1) {
  		                    pv = args[1]
  		                    if (_$add(pn, pv)) {
  		                        _$set(pn, pv)
  		                    }
  		                } else {
  		                    _$add(pn)
  		                }
  		                break
  		            case ARRAY:
  		                // observe properties without value
  		                first.forEach(function (item) {
  		                    _$add(item)
  		                })
  		                break
  		            case OBJECT:
  		                // observe properties with value, if key already exist, reset value only
  		                var resetProps
  		                $util.objEach(first, function (ipn, ipv) {
  		                    if (_$add(ipn, ipv)) {
  		                        !resetProps && (resetProps = {})
  		                        resetProps[ipn] = ipv
  		                    }
  		                })
  		                if (resetProps) _$setMulti(resetProps)
  		                break
  		            default:
  		                $warn('Unexpect params')
  		        }
  		        return this
  		    })
  		    /**
  		     *  define computed prop/props
  		     *  @param propname <String> property name
  		     *  @param deps <Array> computed property dependencies
  		     *  @param fn <Function> computed property getter
  		     *  @param enumerable <Boolean> Optional, whether property enumerable or not
  		     *  --------------------------------------------------
  		     *  @param propsObj <Object> define multiple properties
  		     */
  		    _defPrivateProperty('$computed', function (propname, deps, getFn, setFn, enumerable/* | [propsObj]*/) {
  		        if ($type(propname) == STRING) {
  		            _$computed.apply(null, arguments)
  		        } else if ($type(propname) == OBJECT) {
  		            $util.objEach(arguments[0], function (pn, pv /*propname, propnamevalue*/) {
  		                _$computed(pn, pv.deps, pv.get, pv.set, pv.enum)
  		            })
  		        } else {
  		            $warn('$computed params show be "(String, Array, Function, Function)" or "(Object)"')
  		        }
  		        return this
  		    })
  		    /**
  		     *  subscribe prop change
  		     *  change prop/props value, it will be trigger change event
  		     *  @param kp <String>
  		     *  ---------------------
  		     *  @param kpMap <Object>
  		     */
  		    _defPrivateProperty('$set', function( /*[kp, value] | [kpMap]*/ ) {
  
  		        var args = arguments
  		        var len = args.length
  		        if (len >= 2 || (len == 1 && $type(args[0]) == STRING)) {
  		            _$set(args[0], args[1])
  		        } else if (len == 1 && $type(args[0]) == OBJECT) {
  		            _$setMulti(args[0])
  		        } else {
  		            $warn('Unexpect $set params')
  		        }
  
  		        return this
  		    })
  
  		    /**
  		     *  Get property value by name, using for get value of computed property without cached
  		     *  change prop/props value, it will be trigger change event
  		     *  @param kp <String> keyPath
  		     */
  		    _defPrivateProperty('$get', function(kp) {
  		        if ($indexOf(_observableKeys, kp)) 
  		            return _props[kp]
  		        else if ($indexOf(_computedKeys, kp)) {
  		            return (_computedProps[kp].get || NOOP).call(_computedCtx, model)
  		        } else {
  		            // keyPath
  		            var normalKP = $normalize(kp)
  		            var parts = normalKP.split('.')
  		            if (!$indexOf(_observableKeys, parts[0])) {
  		                return
  		            } else {
  		                return $keypath.get(_props, normalKP)
  		            }
  		        }
  		    })
  		    /**
  		     *  if params is (key, callback), add callback to key's subscription
  		     *  if params is (callback), subscribe any prop change events of this model
  		     *  @param key <String> optional
  		     *  @param callback <Function>
  		     */
  		    _defPrivateProperty('$watch', function( /*[key, ]callback*/ ) {
  		        var args = arguments
  		        var len = args.length
  		        var first = args[0]
  		        var key, callback
  		        if (len >= 2) {
  		            key = 'change:' + $normalize($join(_rootPath(), first))
  		            callback = args[1]
  		        } else if (len == 1 && $type(first) == FUNCTION) {
  		            key = '*'
  		            callback = first
  		        } else {
  		            $warn('Unexpect $watch params')
  		            return NOOP
  		        }
  		        emitter.on(key, callback, __muxid__/*scopre*/)
  		        var that = this
  		        // return a unsubscribe method
  		        return function() {
  		            that.$unwatch.apply(that, args)
  		        }
  		    })
  		    /**
  		     *  unsubscribe prop change
  		     *  if params is (key, callback), remove callback from key's subscription
  		     *  if params is (callback), remove all callbacks from key' ubscription
  		     *  if params is empty, remove all callbacks of current model
  		     *  @param key <String>
  		     *  @param callback <Function>
  		     */
  		    _defPrivateProperty('$unwatch', function( /*[key, ] [callback] */ ) {
  		        var args = arguments
  		        var len = args.length
  		        var first = args[0]
  		        var params
  		        var prefix
  		        switch (true) {
  		            case (len >= 2):
  		                params = [args[1]]
  		            case (len == 1 && $type(first) == STRING):
  		                !params && (params = [])
  		                prefix = CHANGE_EVENT + ':' + $normalize($join(_rootPath(), first))
  		                params.unshift(prefix)
  		                break
  		            case (len == 1 && $type(first) == FUNCTION):
  		                params = ['*', first]
  		                break
  		            case (len == 0):
  		                params = []
  		                break
  		            default:
  		                $warn('Unexpect param type of ' + first)
  		        }
  		        if (params) {
  		            params.push(__muxid__)
  		            emitter.off.apply(emitter, params)
  		        }
  		        return this
  		    })
  		    /**
  		     *  Return all properties without computed properties
  		     *  @return <Object>
  		     */
  		    _defPrivateProperty('$props', function() {
  		        return $util.copyObject(_props)
  		    })
  		    /**
  		     *  Reset event emitter
  		     *  @param em <Object> emitter
  		     */
  		    _defPrivateProperty('$emitter', function (em, _pem) {
  		        // return emitter instance if args is empty, 
  		        // for share some emitter with other instance
  		        if (arguments.length == 0) return emitter
  		        emitter = em
  		        _walkResetEmiter(this.$props(), em, _pem)
  		        return this
  		    })
  		    /**
  		     *  set emitter directly
  		     */
  		    _defPrivateProperty('_$emitter', function (em) {
  		        emitter = em
  		    })
  		    /**
  		     *  set private emitter directly
  		     */
  		    _defPrivateProperty('_$_emitter', function (em) {
  		        instanceOf(em, $Message) && (_emitter = em)
  		    })
  		    /**
  		     *  Call destroy will release all private properties and variables
  		     */
  		    _defPrivateProperty('$destroy', function () {
  		        // clean up all proto methods
  		        $util.objEach(_privateProperties, function (k, v) {
  		            if ($type(v) == FUNCTION && k != '$destroyed') _privateProperties[k] = _destroyNotice
  		        })
  
  		        if (!_isExternalEmitter) emitter.off()
  		        else emitter.off(__muxid__)
  
  		        if (!_isExternalPrivateEmitter) _emitter.off()
  		        else _emitter.off(__muxid__)
  
  		        emitter = null
  		        _emitter = null
  		        _computedProps = null
  		        _computedKeys = null
  		        _cptDepsMapping = null
  		        _cptCaches = null
  		        _observableKeys = null
  		        _props = null
  
  		        // destroy external flag
  		        _destroy = true
  		    })
  		    /**
  		     *  This method is used to check the instance is destroyed or not
  		     */
  		    _defPrivateProperty('$destroyed', function () {
  		        return _destroy
  		    })
  		    /**
  		     *  A shortcut of $set(props) while instancing
  		     */
  		    _$setMulti(receiveProps)
  
  		}
  		/**
  		 *  Reset emitter of the instance recursively
  		 *  @param ins <Mux>
  		 */
  		function _walkResetEmiter (ins, em, _pem) {
  		    if ($type(ins) == OBJECT) {
  		        var items = ins
  		        if (instanceOf(ins, Mux)) {
  		            ins._$emitter(em, _pem)
  		            items = ins.$props()
  		        }
  		        $util.objEach(items, function (k, v) {
  		            _walkResetEmiter(v, em, _pem)
  		        })
  		    } else if ($type(ins) == ARRAY) {
  		        ins.forEach(function (v) {
  		            _walkResetEmiter(v, em, _pem)
  		        })
  		    }
  		}
  
  		function NOOP() {}
  		function instanceOf(a, b) {
  		    return a instanceof b
  		}
  
  		module.exports = Mux
  
  
  	/***/ },
  	/* 2 */
  	/***/ function(module, exports, __webpack_require__) {
  
  		/**
  		 *  Simple Pub/Sub module
  		 *  @author switer <guankaishe@gmail.com>
  		 **/
  		'use strict';
  
  		var $util = __webpack_require__(6)
  		var _patch = $util.patch
  		var _type = $util.type
  		var _scopeDefault = '__default_scope__'
  
  		function Message(context) {
  		    this._obs = {}
  		    this._context = context
  		}
  		var proto = Message.prototype
  		proto.on = function(sub, cb, scope) {
  		    scope = scope || _scopeDefault
  		    _patch(this._obs, sub, [])
  
  		    this._obs[sub].push({
  		        cb: cb,
  		        scope: scope
  		    })
  		}
  
  		/**
  		 *  @param subject <String> subscribe type
  		 *  @param [cb] <Function> callback, Optional, if callback is not exist,
  		 *      will remove all callback of that sub
  		 */
  		proto.off = function( /*subject, cb, scope*/ ) {
  		    var types
  		    var args = arguments
  		    var len = args.length
  		    var cb, scope
  
  		    if (len >= 3) {
  		        // clear all observers of this subject and callback eq "cb"
  		        types = [args[0]]
  		        cb = args[1]
  		        scope = args[2]
  		    } else if (len == 2 && _type(args[0]) == 'function') {
  		        // clear all observers those callback equal "cb"
  		        types = Object.keys(this._obs)
  		        cb = args[0]
  		        scope = args[1]
  		    } else if (len == 2) {
  		        // clear all observers of this subject
  		        types = [args[0]]
  		        scope = args[1]
  		    } else if (len == 1) {
  		        // clear all observes of the scope
  		        types = Object.keys(this._obs)
  		        scope = args[0]
  		    } else {
  		        // clear all observes
  		        this._obs = []
  		        return this
  		    }
  
  		    scope = scope || _scopeDefault
  
  		    var that = this
  		    types.forEach(function(sub) {
  
  		        var obs = that._obs[sub]
  		        if (!obs) return
  		        var nextObs = []
  		        if (cb) {
  		            obs.forEach(function(observer) {
  		                if (observer.cb === cb && observer.scope === scope) {
  		                    return
  		                }
  		                nextObs.push(observer)
  		            })
  		        } else {
  		            obs.forEach(function(observer) {
  		                if (observer.scope === scope) return
  		                nextObs.push(observer)
  		            })
  		        }
  		        // if cb is not exist, clean all observers
  		        that._obs[sub] = nextObs
  
  		    })
  
  		    return this
  		}
  		proto.emit = function(sub) {
  		    var obs = this._obs[sub]
  		    if (!obs) return
  		    var args = [].slice.call(arguments)
  		    args.shift()
  		    var that = this
  		    obs.forEach(function(item) {
  		        item.cb && item.cb.apply(that._context || null, args)
  		    })
  		}
  
  		module.exports = Message
  
  
  	/***/ },
  	/* 3 */
  	/***/ function(module, exports, __webpack_require__) {
  
  		'use strict';
  
  		/**
  		 *  normalize all access ways into dot access
  		 *  @example "person.books[1].title" --> "person.books.1.title"
  		 */
  		function _keyPathNormalize(kp) {
  		    return new String(kp).replace(/\[([^\[\]]+)\]/g, function(m, k) {
  		        return '.' + k.replace(/^["']|["']$/g, '')
  		    })
  		}
  		/**
  		 *  set value to object by keypath
  		 */
  		function _set(obj, keypath, value, hook) {
  		    var parts = _keyPathNormalize(keypath).split('.')
  		    var last = parts.pop()
  		    var dest = obj
  		    parts.forEach(function(key) {
  		        // Still set to non-object, just throw that error
  		        dest = dest[key]
  		    })
  		    if (hook) {
  		        // hook proxy set value
  		        hook(dest, last, value)
  		    } else {
  		        dest[last] = value
  		    }
  		    return obj
  		}
  		/**
  		 *  Get undefine
  		 */
  		function undf () {
  		    return void(0)
  		}
  		function isNon (o) {
  		    return o === undf() || o === null
  		}
  		/**
  		 *  get value of object by keypath
  		 */
  		function _get(obj, keypath) {
  		    var parts = _keyPathNormalize(keypath).split('.')
  		    var dest = obj
  		    parts.forEach(function(key) {
  		        if (isNon(dest)) return !(dest = undf())
  		        dest = dest[key]
  		    })
  		    return dest
  		}
  
  		/**
  		 *  append path to a base path
  		 */
  		function _join(pre, tail) {
  		    var _hasBegin = !!pre
  		    if(!_hasBegin) pre = ''
  		    if (/^\[.*\]$/.exec(tail)) return pre + tail
  		    else if (typeof(tail) == 'number') return pre + '[' + tail + ']'
  		    else if (_hasBegin) return pre + '.' + tail
  		    else return tail
  		}
  		/**
  		 *  remove the last section of the keypath
  		 *  digest("a.b.c") --> "a.b"
  		 */
  		function _digest(nkp) {
  		    var reg = /(\.[^\.]+|\[([^\[\]])+\])$/
  		    if (!reg.exec(nkp)) return ''
  		    return nkp.replace(reg, '')
  		}
  		module.exports = {
  		    normalize: _keyPathNormalize,
  		    set: _set,
  		    get: _get,
  		    join: _join,
  		    digest: _digest
  		}
  
  
  	/***/ },
  	/* 4 */
  	/***/ function(module, exports, __webpack_require__) {
  
  		'use strict';
  
  		var $util = __webpack_require__(6)
  		var hookMethods = ['splice', 'push', 'pop', 'shift', 'unshift', 'reverse', 'sort', '$concat']
  		var _push = Array.prototype.push
  		var _slice = Array.prototype.slice
  		var attachMethods = {
  		    '$concat': function () {
  		        var args = _slice.call(arguments)
  		        var arr = this
  		        args.forEach(function (items) {
  		            $util.type(items) == 'array' 
  		                ? items.forEach(function (item) {
  		                        _push.call(arr, item)
  		                    })
  		                : _push.call(arr, items)
  		        })
  		        return arr
  		    }
  		}
  		var hookFlag ='__hook__'
  
  		module.exports = function (arr, hook) {
  		    hookMethods.forEach(function (m) {
  		        if (arr[m] && arr[m][hookFlag]) {
  		            // reset hook method
  		            arr[m][hookFlag](hook)
  		            return
  		        }
  		        // cached native method
  		        var nativeMethod = arr[m] || attachMethods[m]
  		        // method proxy
  		        $util.def(arr, m, {
  		            enumerable: false,
  		            value: function () {
  		                return hook(arr, m, nativeMethod, arguments)
  		            }
  		        })
  		        // flag mark
  		        $util.def(arr[m], hookFlag, {
  		            enumerable: false,
  		            value: function (h) {
  		                hook = h
  		            }
  		        })
  		    })
  		}
  
  	/***/ },
  	/* 5 */
  	/***/ function(module, exports, __webpack_require__) {
  
  		'use strict';
  
  		var _enable = true
  
  		module.exports = {
  		    enable: function () {
  		        _enable = true
  		    },
  		    disable: function () {
  		        _enable = false
  		    },
  		    warn: function (msg) {
  		        if (!_enable) return
  		        if (console.warn) return console.warn(msg)
  		        console.log(msg)
  		    }
  		}
  
  	/***/ },
  	/* 6 */
  	/***/ function(module, exports, __webpack_require__) {
  
  		'use strict';
  		function hasOwn (obj, prop) {
  		    return obj && obj.hasOwnProperty(prop)
  		}
  		module.exports = {
  		    type: function (obj) {
  		        return /\[object (\w+)\]/.exec(Object.prototype.toString.call(obj))[1].toLowerCase()
  		    },
  		    objEach: function (obj, fn) {
  		        if (!obj) return
  		        for(var key in obj) {
  		            if (hasOwn(obj, key)) {
  		                if(fn(key, obj[key]) === false) break
  		            }
  		        }
  		    },
  		    patch: function (obj, prop, defValue) {
  		        !obj[prop] && (obj[prop] = defValue)
  		    },
  		    diff: function (next, pre, _t) {
  		        var that = this
  		        // defult max 4 level        
  		        _t = _t == undefined ? 4 : _t
  
  		        if (_t <= 0) return next !== pre
  
  		        if (this.type(next) == 'array' && this.type(pre) == 'array') {
  		            if (next.length !== pre.length) return true
  		            return next.some(function(item, index) {
  		                return that.diff(item, pre[index], _t - 1)
  		            })
  		        } else if (this.type(next) == 'object' && this.type(pre) == 'object') {
  		            var nkeys = Object.keys(next)
  		            var pkeys = Object.keys(pre)
  		            if (nkeys.length != pkeys.length) return true
  
  		            var that = this
  		            return nkeys.some(function(k) {
  		                return (!~pkeys.indexOf(k)) || that.diff(next[k], pre[k], _t - 1)
  		            })
  		        }
  		        return next !== pre
  		    },
  		    copyArray: function (arr) {
  		        var len = arr.length
  		        var nArr = new Array(len)
  		        while(len --) {
  		            nArr[len] = arr[len]
  		        }
  		        return nArr
  		    },
  		    copyObject: function (obj) {
  		        var cObj = {}
  		        this.objEach(obj, function (k, v) {
  		            cObj[k] = v
  		        })
  		        return cObj
  		    },
  		    copyValue: function (v) {
  		        var t = this.type(v)
  		        switch(t) {
  		            case 'object': return this.copyObject(v)
  		            case 'array': return this.copyArray(v)
  		            default: return v
  		        }
  		    },
  		    def: function () {
  		        return Object.defineProperty.apply(Object, arguments)
  		    },
  		    indexOf: function (a, b) {
  		        return ~a.indexOf(b)
  		    },
  		    merge: function (to, from) {
  		        if (!from) return to
  		        this.objEach(from, function (k, v) {
  		            to[k] = v
  		        })
  		        return to
  		    },
  		    hasOwn: hasOwn
  		}
  
  	/***/ }
  	/******/ ])
  	});
  	;
  
  /***/ },
  /* 5 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var Mux = __webpack_require__(4)
  	var mUtils = Mux.utils
  	var _normalize = Mux.keyPath.normalize
  	var _digest = Mux.keyPath.digest
  
  	function _keys(o) {
  	    return Object.keys(o)
  	}
  	function _forEach (items, fn) {
  	    var len = items.length || 0
  	    for (var i = 0; i < len; i ++) {
  	        if(fn(items[i], i)) break
  	    }
  	}
  	function _slice (obj) {
  	    if (!obj) return []
  	    return [].slice.call(obj)
  	}
  	var escapeCharMap = {
  	    '&': '&amp;',
  	    '<': '&lt;',
  	    '>': '&gt;',
  	    '\"': '&quot;',
  	    '\'': '&#x27;',
  	    '/': '&#x2F;'
  	}
  	var escapeRex = new RegExp(_keys(escapeCharMap).join('|'), 'g')
  	module.exports = {
  	    type: mUtils.type,
  	    diff: mUtils.diff,
  	    merge: mUtils.merge,
  	    objEach: mUtils.objEach,
  	    copyArray: mUtils.copyArray,
  	    copyObject: mUtils.copyObject,
  	    
  	    extend: function(obj) {
  	        if (this.type(obj) != 'object') return obj;
  	        var source, prop;
  	        for (var i = 1, length = arguments.length; i < length; i++) {
  	            source = arguments[i];
  	            for (prop in source) {
  	                obj[prop] = source[prop];
  	            }
  	        }
  	        return obj;
  	    },
  	    valueDiff: function(next, pre) {
  	        return next !== pre || next instanceof Object
  	    },
  	    walk: function(node, fn) {
  	        var into = fn(node) !== false
  	        var that = this
  	        if (into) {
  	            _slice(node.childNodes).forEach(function (node) {
  	                that.walk(node, fn)
  	            })
  	        }
  	    },
  	    domRange: function (tar, before, after) {
  	        var children = []
  	        var nodes = tar.childNodes
  	        var start = false
  	        for (var i = 0; i < nodes.length; i++) {
  	            var item = nodes[i]
  	            if (item === after) break
  	            else if (start) {
  	                children.push(item)
  	            } else if (item == before) {
  	                start = true
  	            }
  	        }
  	        return children
  	    },
  	    immutable: function (obj) {
  	        var that = this
  	        var _t = this.type(obj)
  	        var n
  
  	        if (_t == 'array') {
  	            n = obj.map(function (item) {
  	                return that.immutable(item)
  	            })
  	        } else if (_t == 'object') {
  	            n = {}
  	            this.objEach(obj, function (k, v) {
  	                n[k] = that.immutable(v)
  	            })
  	        } else {
  	            n = obj
  	        }
  	        return n
  	    },
  	    tagHTML: function (tag) {
  	        var h = tag.outerHTML
  	        var open = h.match(/^<[^>]+?>/)
  	        var close = h.match(/<\/[^<]+?>$/)
  	        
  	        return [open ? open[0]:'', close ? close[0]:'']
  	    },
  	    relative: function (src, dest) {
  	        src = _normalize(src)
  	        dest = _normalize(dest)
  
  	        if (src == dest) return true
  	        else {
  	            var start = src.indexOf(dest) === 0
  	            var subkp = src.replace(dest, '').match(/^[\.\[]/)
  	            return start && subkp
  	        }
  	    },
  	    escape: function (str) {
  	        if (!this.type(str) == 'string') return str
  	        return str.replace(escapeRex, function (m) {
  	            return escapeCharMap[m]
  	        })
  	    },
  	    isUndef: function (o) {
  	        return this.type(o) === 'undefined'
  	    },
  	    isNon: function (o) {
  	        var t = this.type(o)
  	        return t === 'undefined' || t === 'null'
  	    },
  	    forEach: _forEach,
  	    normalize: _normalize,
  	    digest: _digest
  	}
  
  
  /***/ },
  /* 6 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var _ns = 'z-' // default namespace is z that means "Zect" 
  
  	module.exports = {
  	    set namespace (n) {
  	        _ns = n + '-'
  	    },
  	    get namespace () {
  	        return _ns
  	    }
  	 }
  
  /***/ },
  /* 7 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 *  execute expression from template with specified Scope and ViewModel
  	 */
  
  	var util = __webpack_require__(5)
  	/**
  	 *  Calc expression value
  	 */
  	function _execute($vm, $scope/*, expression, [label], [target]*/) {
  	    /**
  	     *  $scope is passed when call instance method $compile, 
  	     *  Each "scope" object maybe include "$parent, data, method" properties
  	     */
  	    var $parent = $scope && $scope.$parent ? util.extend({}, $scope.$parent.methods, $scope.$parent.data) : {}
  	    
  	    $scope = $scope || {}
  	    $scope = util.extend({}, $vm.$methods, $vm.$data, $scope.methods, $scope.data)
  
  	    try {
  	        return util.immutable(eval('with($scope){(%s)}'.replace('%s', arguments[2])))
  	    } catch (e) {
  	        arguments[2] = /^\{/.test(arguments[2]) 
  	                        ? '. ' + arguments[2]
  	                        : '. {' + arguments[2] + '}' // expr
  	        // arguments[3] // label
  	        // arguments[4] // target
  	        switch (e.name) {
  	            case 'ReferenceError':
  	                console.warn(e.message + arguments[2])
  	                break
  	            default:
  	                console.error(
  	                     (arguments[3] ? '\'' + arguments[3] + '\': ' : ''),
  	                    e.message + arguments[2],
  	                    arguments[4] || ''
  	                )
  	        }
  	        return ''
  	    }
  	}
  	module.exports = _execute
  
  /***/ },
  /* 8 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var $ = __webpack_require__(2)
  	var util = __webpack_require__(5)
  	var Expression = __webpack_require__(9)
  	var _execute = __webpack_require__(7)
  	var _relative = util.relative
  	/**
  	 *  Whether a text is with express syntax
  	 */
  	var _isExpr = Expression.isExpr
  	/**
  	 *  Get varibales of expression
  	 */
  	var _extractVars = Expression.extract
  
  	function noop () {}
  
  	var keywords = ['$index', '$value', '$parent', '$vm', '$scope']
  	/**
  	 *  watch changes of variable-name of keypath
  	 *  @return <Function> unwatch
  	 */
  	function _watch(vm, vars, update) {
  	    var watchKeys = []
  	    function _handler (kp) {
  	        if (watchKeys.some(function(key, index) {
  	                if (_relative(kp, key)) {
  	                    return true
  	                }
  	        })) update.apply(null, arguments)
  	    }
  
  	    if (vars && vars.length) {
  	        vars.forEach(function (k) {
  	            if (~keywords.indexOf(k)) return
  	            while (k) {
  	                if (!~watchKeys.indexOf(k)) watchKeys.push(k)
  	                k = util.digest(k)
  	            }
  	        })
  	        if (!watchKeys.length) return noop
  	        vm.$watch(_handler)
  	        return function () {
  	            vm.$unwatch(_handler)
  	        }
  	    }
  	    return noop
  	}
  
  
  	var _strip = Expression.strip
  
  	/**
  	 *  Compoiler constructor for wrapping node with consistent API
  	 *  @node <Node>
  	 */
  	function Compiler (node) {
  	    this.$el = node
  	}
  
  	var cproto = Compiler.prototype
  
  	Compiler.inherit = function (Ctor) {
  	    Ctor.prototype = Object.create(Compiler.prototype)
  	    return Ctor
  	}
  	cproto.$bundle = function () {
  	    return this.$el
  	}
  	cproto.$floor = function () {
  	    return this.$el
  	}
  	cproto.$ceil = function () {
  	    return this.$el
  	}
  	cproto.$mount = function (pos) {
  	    $(pos).replace(this.$bundle())
  	    return this
  	}
  	cproto.$remove = function () {
  	    var $el = this.$bundle()
  	    _parentNode($el) && $($el).remove()
  	    return this
  	}
  	cproto.$appendTo = function (pos) {
  	    _appendChild(pos, this.$bundle())
  	    return this
  	}
  	cproto.$insertBefore = function (pos) {
  	    _insertBefore(_parentNode(pos), this.$bundle(), pos)
  	    return this
  	}
  	cproto.$insertAfter = function (pos) {
  	    _insertBefore(_parentNode(pos), this.$bundle(), _nextSibling(pos))
  	    return this
  	}
  	cproto.$destroy = function () {
  	    this.$el = null
  	    return this
  	}
  	function _nextTo (src, tar) {
  	    var next = tar.nextSibling
  	    while(next) {
  	        if (next === src) return true
  	        else if (next.nodeType == 3 && /^\s*$/m.test(next.nodeValue)) {
  	            next = next.nextSibling
  	            continue
  	        } else {
  	            break
  	        }
  	    }
  	    return false
  	}
  	cproto.$nextTo = function (tar) {
  	    // Compiler of Node
  	    tar = tar instanceof Compiler ? tar.$ceil() : tar
  	    return _nextTo(tar, this.$floor())
  	}
  	cproto.$preTo = function (tar) {
  	    tar = tar instanceof Compiler ? tar.$floor() : tar
  	    return _nextTo(this.$ceil(), tar)
  	}
  	/**
  	 * Can be overwrited
  	 * @type {[type]}
  	 */
  	cproto.$update = noop
  	/**
  	 *  Standard directive
  	 */
  	var _did = 0
  	Compiler.Directive = Compiler.inherit(function Directive (vm, scope, tar, def, name, expr) {
  	    var d = this
  	    var bindParams = []
  	    var isExpr = !!_isExpr(expr)
  
  	    d.$expr = expr
  	    
  	    isExpr && (expr = _strip(expr))
  
  	    if (def.multi) {
  	        // extract key and expr from "key: expression" format
  	        var key
  	        expr = expr.replace(/^[^:]+:/, function (m) {
  	            key = m.replace(/:$/, '').trim()
  	            return ''
  	        }).trim()
  	        
  	        bindParams.push(key)
  	    }
  
  	    d.$id = _did++
  	    d.$name = name
  	    d.$el = tar
  	    d.$vm = vm
  	    d.$scope = scope
  
  	    var bind = def.bind
  	    var unbind = def.unbind
  	    var upda = def.update
  	    var prev
  	    var unwatch
  
  
  	    // set properties
  	    util.objEach(def, function (k, v) {
  	        d[k] = v
  	    })
  	    
  	    /**
  	     *  execute wrap with directive name
  	     */
  	    function _exec(expr) {
  	        return _execute(vm, scope, expr, name)
  	    }
  
  	    /**
  	     *  update handler
  	     */
  	    function _update(kp) {
  	        var nexv = _exec(expr)
  	        if (util.diff(nexv, prev)) {
  	            var p = prev
  	            prev = nexv
  	            upda && upda.call(d, nexv, p, kp)
  	        }
  	    }
  
  	    /**
  	     *  If expression is a string iteral, use it as value
  	     */
  	    prev = isExpr ? _exec(expr):expr
  	    bindParams.push(prev)
  	    bindParams.push(expr)
  	    // watch variable changes of expression
  	    if (def.watch !== false && isExpr) {
  	       unwatch = _watch(vm, _extractVars(expr), _update)
  	    }
  
  	    d.$destroy = function () {
  	        unbind && unbind.call(d)
  	        unwatch && unwatch()
  	        d.$el = null
  	        d.$vm = null
  	        d.$scope = null
  	    }
  	    d.$update = _update
  
  	    // ([property-name], expression-value, expression) 
  	    bind && bind.apply(d, bindParams, expr)
  	    upda && upda.call(d, prev)
  
  	})
  
  
  	var _eid = 0
  	Compiler.Element = Compiler.inherit(function ZElement(vm, scope, tar, def, name, expr) {
  	    var d = this
  	    var bind = def.bind
  	    var unbind = def.unbind
  	    var upda = def.update
  	    var delta = def.delta
  	    var deltaUpdate = def.deltaUpdate
  	    var isExpr = !!_isExpr(expr)
  	    var prev
  	    var unwatch
  
  	    d.$expr = expr
  
  	    isExpr && (expr = _strip(expr))
  	    d.$id = _eid ++
  	    d.$name = name
  	    d.$vm = vm
  	    d.$el = tar
  	    d.$scope = scope // save the scope reference
  
  	    var tagHTML = util.tagHTML(tar)
  	    d.$before = _createComment(tagHTML[0])
  	    d.$after = _createComment(tagHTML[1])
  	    d.$container = document.createDocumentFragment()
  
  	    _appendChild(d.$container, d.$before)
  	    _appendChild(d.$container, d.$after)
  
  	    // set properties
  	    util.objEach(def, function (k, v) {
  	        d[k] = v
  	    })
  
  	    d.$bundle = function () {
  	        var $ceil = this.$ceil()
  	        var $floor = this.$floor()
  	        var $con = this.$container
  	        var that = this
  
  	        if (!_contains($con, $ceil)) {
  	            util.domRange(_parentNode($ceil), $ceil, $floor)
  	                .forEach(function(n) {
  	                    _appendChild(that.$container, n)
  	                })
  	            _insertBefore($con, $ceil, $con.firstChild)
  	            _appendChild($con, $floor)
  	        }
  	        return $con
  	    }
  	    d.$floor = function () {
  	        return this.$after
  	    }
  	    d.$ceil = function () {
  	        return this.$before
  	    }
  
  	    d.$destroy = function () {
  	        unbind && unbind.call(d)
  	        unwatch && unwatch()
  	        d.$el = null
  	        d.$vm = null
  	        d.$scope = null
  	    }
  	    /**
  	     *  update handler
  	     */
  	    function _update(kp, nv, pv, method, ind, len) {
  	        var nexv = _exec(expr)
  	        var deltaResult 
  	        if ( delta && (deltaResult = delta.call(d, nexv, prev, kp)) ) {
  	            return deltaUpdate && deltaUpdate.call(d, nexv, p, kp, deltaResult)
  	        }
  	        if (util.diff(nexv, prev)) {
  	            var p = prev
  	            prev = nexv
  	            upda && upda.call(d, nexv, p, kp, method, ind, len)
  	        }
  	    }
  
  	    d.$update = _update
  
  	    /**
  	     *  execute wrap with directive name
  	     */
  	    function _exec(expr) {
  	        return _execute(vm, scope, expr, name)
  	    }
  
  	    prev = isExpr ? _exec(expr) : expr
  	    if (def.watch !== false && isExpr) {
  	        unwatch = _watch(vm, _extractVars(expr), _update)
  	    }
  	    bind && bind.call(d, prev, expr)
  	    upda && upda.call(d, prev)
  	})
  
  
  	Compiler.Text = Compiler.inherit(function ZText(vm, scope, tar, originExpr, parts, exprs) {
  	    this.$expr = originExpr
  
  	    function _exec (expr) {
  	        return _execute(vm, scope, expr, null)
  	    }
  	    var cache = new Array(exprs.length)
  	    var isUnescape = exprs.some(function (expr) {
  	        return Expression.isUnescape(expr)
  	    })
  	    var unwatches = []
  
  	    exprs.forEach(function(exp, index) {
  	        // watch change
  	        exp = _strip(exp)
  	        var vars = _extractVars(exp)
  
  	        function _update() {
  	            var pv = cache[index]
  	            var nv = _exec(exp)
  
  	            if (util.diff(nv, pv)) {
  	                // re-render
  	                cache[index] = nv
  	                render()
  	            }
  	        }
  	        // initial value
  	        cache[index] = _exec(exp)
  
  	        unwatches.push(_watch(vm, vars, _update))
  	    })
  
  	    if (isUnescape) {
  	        var $tmp = document.createElement('div')
  	        var $con = document.createDocumentFragment()
  	        var $before = _createComment('{' + _strip(originExpr))
  	        var $after = _createComment('}')
  
  	        var pn = _parentNode(tar)
  	        _insertBefore(pn, $before, tar)
  	        _insertBefore(pn, $after, _nextSibling(tar))
  	    }
  
  	    function render() {
  	        var frags = []
  	        parts.forEach(function(item, index) {
  	            frags.push(item)
  	            if (index < exprs.length) {
  	                frags.push(cache[index])
  	            }
  	        })
  
  	        var value = Expression.unveil(frags.join(''))
  
  	        if (isUnescape) {
  	            var cursor = _nextSibling($before)
  	            while(cursor && cursor !== $after) {
  	                var next = _nextSibling(cursor)
  	                _parentNode(cursor).removeChild(cursor)
  	                cursor = next
  	            }
  	            $tmp.innerHTML = value
  	            ;[].slice.call($tmp.childNodes).forEach(function (n) {
  	                _appendChild($con, n)
  	            }) 
  	            _insertBefore(_parentNode($after), $con, $after)
  	        } else {
  	            tar.nodeValue = value
  	        }
  	    }
  
  	    this.$destroy = function () {
  	        unwatches.forEach(function (f) {
  	            f()
  	        })
  	    }
  
  	    this.$update = function () {
  	        var hasDiff
  	        exprs.forEach(function(exp, index) {
  	            exp = _strip(exp)
  	            var pv = cache[index]
  	            var nv = _exec(exp)
  
  	            if (!hasDiff && util.diff(nv, pv)) {
  	                hasDiff = true
  	            }
  	            cache[index] = nv
  	        })
  	        hasDiff && render()
  	    }
  
  	    /**
  	     *  initial render
  	     */
  	    render()
  	})
  
  	Compiler.Attribute = function ZAttribute (vm, scope, tar, name, value) {
  	    this.$name = name
  	    this.$expr = value
  
  	    var isNameExpr = _isExpr(name)
  	    var isValueExpr = _isExpr(value)
  
  	    var nexpr = isNameExpr ? _strip(name) : null
  	    var vexpr = isValueExpr ? _strip(value) : null
  
  	    var unwatches = []
  
  	    function _exec(expr) {
  	        return _execute(vm, scope, expr, name + '=' + value)
  	    }
  	    // validate atrribute name, from: http://www.w3.org/TR/REC-xml/#NT-NameChar
  	    // /^(:|[a-zA-Z0-9]|_|-|[\uC0-\uD6]|[\uD8-\uF6]|[\uF8-\u2FF]|[\u370-\u37D]|[\u37F-\u1FFF]|[\u200C-\u200D]|[\u2070-\u218F]|[\u2C00-\u2FEF]|[\u3001-\uD7FF]|[\uF900-\uFDCF]|[\uFDF0-\uFFFD]|[\u10000-\uEFFFF])+$/
  
  	    // cache last name/value
  	    var preName = isNameExpr ? _exec(nexpr) : name
  	    var preValue = isValueExpr ? _exec(vexpr) : value
  	    var $tar = $(tar)
  	    function _emptyUndef(v) {
  	        return util.isUndef(v) ? '' : v
  	    }
  	    $tar.attr(preName, _emptyUndef(preValue))
  
  	    function _updateName() {
  	        var next = _exec(nexpr)
  
  	        if (util.diff(next, preName)) {
  	            $tar.removeAttr(preName)
  	                  .attr(next, _emptyUndef(preValue))
  	            preValue = next
  	        }
  	    }
  	    function _updateValue() {
  	        var next = _exec(vexpr)
  	        if (util.diff(next, preValue)) {
  	            $tar.attr(preName, _emptyUndef(next))
  	            preValue = next
  	        }
  	    }
  
  
  	    this.$destroy = function () {
  	        unwatches.forEach(function (f) {
  	            f()
  	        })
  	    }
  
  	    this.$update = function () {
  	        isNameExpr && _updateName()
  	        isValueExpr && _updateValue()
  	    }
  	    /**
  	     *  watch attribute name expression variable changes
  	     */
  	    if (isNameExpr) {
  	        unwatches.push(_watch(vm, _extractVars(name), _updateName))
  	    }
  	    /**
  	     *  watch attribute value expression variable changes
  	     */
  	    if (isValueExpr) {
  	        unwatches.push(_watch(vm, _extractVars(value), _updateValue))
  	    }
  
  	}
  
  	function _appendChild (con, child) {
  	    return con.appendChild(child)
  	}
  	function _createComment (ns) {
  	    return document.createComment(ns)
  	}
  	function _insertBefore (con, child, pos) {
  	    return con.insertBefore(child, pos)
  	}
  	function _parentNode (tar) {
  	    return tar && tar.parentNode
  	}
  	function _nextSibling (tar) {
  	    return tar && tar.nextSibling
  	}
  	function _contains (con, tar) {
  	    return tar && tar.parentNode === con
  	}
  
  	module.exports = Compiler
  
  
  /***/ },
  /* 9 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var execute = __webpack_require__(7)
  	var util = __webpack_require__(5)
  	var _sep = ';'
  	var _sepRegexp = new RegExp(_sep, 'g')
  	var _literalSep = ','
  	var _exprRegexp = /\{[\s\S]*?\}/g
  	var _varsRegexp = /("|').+?[^\\]\1|\.\w*|\$\w*|\w*:|\b(?:this|true|false|null|undefined|new|typeof|Number|String|Object|Array|Math|Date|JSON)\b|([a-z_]\w*)\(|([a-z_]\w*)/gi
  	/**
  	 *  Whether a text is with express syntax
  	 */
  	function _isExpr(c) {
  	    return c ? !!c.trim().match(/^\{[\s\S]*?\}$/m) : false
  	}
  	module.exports = {
  	    sep: _sep,
  	    literalSep: _literalSep,
  
  	    sepRegexp: _sepRegexp,
  	    exprRegexp: _exprRegexp,
  
  	    isExpr: _isExpr,
  	    isUnescape: function(expr) {
  	        return !!expr.match(/^\{\- /)
  	    },
  	    execLiteral: function (expr, vm, scope) {
  	        if (!_isExpr(expr)) return {}
  	        return execute(vm, scope, expr.replace(_sepRegexp, _literalSep))
  	    },
  	    veil: function (expr) {
  	        return expr.replace(/\\{/g, '\uFFF0')
  	                   .replace(/\\}/g, '\uFFF1')
  	    },
  	    unveil: function (expr) {
  	        return expr.replace(/\uFFF0/g, '\\{')
  	                   .replace(/\uFFF1/g, '\\}')
  	    },
  	    strip: function (expr) {
  	        return expr.trim()
  	                .match(/^\{([\s\S]*)\}$/m)[1]
  	                .replace(/^- /, '')
  	    },
  	    extract: function(expr) {
  	        if (!expr) return null
  	        var vars = expr.match(_varsRegexp)
  	        vars = !vars ? [] : vars.filter(function(i) {
  	            if (!i.match(/^[\."'\]\[]/) && !i.match(/\($/)) {
  	                return i
  	            }
  	        })
  	        return vars
  	    },
  	    /**
  	     * abc
  	     * abc.0
  	     * abc[0]
  	     * abc[0].abc
  	     * abc["xx-xx"] || abc['xx-xx']
  	     */
  	    variableOnly: function (expr) {
  	        return !util.normalize(expr || '').split('.').some(function (k) {
  	            return !k.match(/^([a-zA-Z_$][\w$]*|\d+|".*"|'.*')$/)  
  	        })
  	    },
  	    notFunctionCall: function (expr) {
  	        return !/[()]/.test(expr)
  	    }
  	}
  
  /***/ },
  /* 10 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 *  Build-in Global Directives
  	 */
  
  	'use strict';
  
  	var $ = __webpack_require__(2)
  	var conf = __webpack_require__(6)
  	var util = __webpack_require__(5)
  
  
  	module.exports = function(Zect) {
  	    return {
  	        'attr': {
  	            multi: true,
  	            bind: function(attname) {
  	                this.attname = attname
  	                this._$el = $(this.$el)
  	            },
  	            update: function(next) {
  	                if (util.isUndef(next)) {
  	                    this._$el.removeAttr(this.attname)
  	                } else {
  	                    this._$el.attr(this.attname, next)
  	                }
  	            },
  	            unbind: function () {
  	                this._$el = this.attname = null
  	            }
  	        },
  	        'class': {
  	            multi: true,
  	            bind: function(className) {
  	                this.className = className
  	                this._$el = $(this.$el)
  	            },
  	            update: function(next) {
  	                if (next) this._$el.addClass(this.className)
  	                else this._$el.removeClass(this.className)
  	            },
  	            unbind: function () {
  	                this._$el = this.className = null
  	            }
  	        },
  	        'html': {
  	            update: function (nextHTML) {
  	                this.$el.innerHTML = nextHTML
  	            }
  	        },
  	        'model': {
  	            bind: function (prop) {
  	                var tagName = this.$el.tagName
  	                var type = tagName.toLowerCase()
  	                var $el = this._$el = $(this.$el)
  
  	                // pick input element type spec
  	                type = type == 'input' ? $el.attr('type') || 'text' : type
  
  	                switch (type) {
  	                    case 'tel':
  	                    case 'url':
  	                    case 'text':
  	                    case 'search':
  	                    case 'password':
  	                    case 'textarea':
  	                        this.evtType = 'input'
  	                        break
  	                    
  	                    case 'date':
  	                    case 'week':
  	                    case 'time':
  	                    case 'month':
  	                    case 'datetime':
  	                    case 'datetime-local':
  	                    case 'color':
  	                    case 'range':
  	                    case 'number':
  	                    case 'select':
  	                    case 'checkbox':
  	                        this.evtType = 'change'
  	                        break
  	                    default:
  	                        console.warn('"' + conf.namespace + 'model" only support input,textarea,select')
  	                        return
  	                }
  
  	                var vm = this.$vm
  	                var _update = this.$update
  	                var vType = type == 'checkbox' ? 'checked':'value'
  	                var that = this
  
  	                /**
  	                 *  DOM input 2 state
  	                 */
  	                this._requestChange = function () {
  	                    vm.$set(that._prop, that.$el[vType])
  	                }
  	                /**
  	                 *  State 2 DOM input
  	                 */
  	                this._update = function () {
  	                    that.$el[vType] = vm.$get(that._prop)
  	                }
  	                this.$update = function () {
  	                    that._update()
  	                    _update && _update.apply(this, arguments)
  	                }
  	                $el.on(this.evtType, this._requestChange)
  	                var watches = this._watches = []
  	                var wKeypath = util.normalize(prop)
  	                while (wKeypath) {
  	                    watches.push(this.$vm.$watch(wKeypath, this._update))
  	                    wKeypath = util.digest(wKeypath)
  	                }
  	            },
  	            update: function (prop) {
  	                this._prop = prop
  	                this._update()
  	            },
  	            unbind: function () {
  	                this._$el.off(this.evtType, this._requestChange)
  	                this._watches.forEach(function (f) {
  	                    f()
  	                })
  	                this._$el = null
  	                this._requestChange = this._update = noop
  	            }
  	        },
  	        'on': {
  	            multi: true,
  	            watch: false,
  	            bind: function(evtType, handler, expression ) {
  	                this._expr = expression
  	                this.type = evtType
  	                this._$el = $(this.$el)
  	            },
  	            update: function (handler) {
  	                this.off()
  	                var fn = handler
  	                if (util.type(fn) !== 'function') 
  	                    return console.warn('"' + conf.namespace + 'on" only accept function. {' + this._expr + '}')
  
  	                this.fn = fn.bind(this.$vm)
  	                this._$el.on(this.type, this.fn, false)
  
  	            },
  	            off: function () {
  	                if (this.fn) {
  	                    this._$el && this._$el.off(this.type, this.fn)
  	                    this.fn = null
  	                }
  	            },
  	            unbind: function() {
  	                this.off()
  	                this._$el = this.type = null
  	            }
  	        },
  	        'show': {
  	            update: function(next) {
  	                this.$el.style.display = next ? '' : 'none'
  	            }
  	        },
  	        'style': {
  	            multi: true,
  	            bind: function (sheet) {
  	                this.sheet = sheet
  	            },
  	            update: function (next) {
  	                this.$el.style && (this.$el.style[this.sheet] = next)
  	            },
  	            unbind: function () {
  	                this.sheet = null
  	            }
  	        },
  	        'src': {
  	            bind: function () {
  	                this._$el = $(this.$el)
  	            },
  	            update: function (src) {
  	                if (util.isNon(src)) {
  	                    this._$el.removeAttr('src')
  	                } else {
  	                    this._$el.attr('src', src)
  	                }
  	            },
  	            unbind: function () {
  	                this._$el = null
  	            }
  	        }
  	    }
  	}
  	function noop () {}
  
  /***/ },
  /* 11 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 *  Build-in Global Custom-Elements
  	 */
  
  	'use strict';
  
  	var $ = __webpack_require__(2)
  	var conf = __webpack_require__(6)
  	var util = __webpack_require__(5)
  	var Scope = __webpack_require__(12)
  	var Expression = __webpack_require__(9)
  
  	module.exports = function(Zect) {
  	    return {
  	        'if': {
  	            bind: function(/*cnd, expr*/) {
  	                this._tmpCon = document.createDocumentFragment()
  	                /**
  	                 *  Initial unmount childNodes
  	                 */
  	                ;[].slice
  	                    .call(this.$el.childNodes)
  	                    .forEach(function(e) {
  	                        this._tmpCon.appendChild(e)
  	                    }.bind(this))
  
  	                /**
  	                 *  Instance method
  	                 */
  	                var mounted
  	                this._mount = function () {
  	                    if (mounted) return
  	                    mounted = true
  	                    var $floor = this.$floor()
  	                    $floor.parentNode.insertBefore(this._tmpCon, $floor)
  
  	                }
  	                this._unmount = function () {
  	                    if (!mounted) return
  	                    mounted = false
  	                    var $ceil = this.$ceil()
  	                    var $floor = this.$floor()
  
  	                    var that = this
  	                    util.domRange($ceil.parentNode, $ceil, $floor)
  	                        .forEach(function(n) {
  	                            that._tmpCon.appendChild(n)
  	                        })
  	                }
  	            },
  	            update: function(next) {
  	                if (!next) {
  	                    this._unmount()
  	                } else if (this.compiled) {
  	                    this._mount()
  	                } else {
  	                    this.compiled = true
  
  	                    var $parent = this.$scope || new Scope()
  	                    // inherit parent scope's properties
  	                    var $scope = new Scope($parent.data, $parent)
  	                    var protoUpdate = $scope.$update
  	                    $scope.$update = function () {
  	                        // the "if" element is sharing with $scope.data, 
  	                        // so it need to be updated
  	                        $scope.data = $parent.data
  	                        protoUpdate.apply($scope, arguments)
  	                    }
  	                    var $update = this.$update
  
  	                    // hook to $update interface
  	                    this.$update = function () {
  	                        $scope.$update()
  	                        $update.apply(this, arguments)
  	                    }
  	                    if(this.$scope) {
  	                        this.$scope.children.push($scope)
  	                    }
  	                    this.$vm.$compile(this._tmpCon, $scope)
  	                    this._mount()
  	                }
  	            }
  	        },
  	        'repeat': {
  	            bind: function(items, expr) {
  	                this.child = this.$el.firstElementChild
  	                this.expr = expr
  	                if (!this.child) {
  	                    return console.warn('"' + conf.namespace + 'repeat"\'s childNode must has a HTMLElement node. {' + expr + '}')
  	                }
  	                // if use filter, Zect can't patch array by array-method
  	                this._noArrayFilter = Expression.notFunctionCall(expr)
  	            },
  	            delta: function (nv, pv, kp) {
  	                if (!kp) return false
  	                var exprProp = util.normalize(Expression.strip(this.$expr).trim())
  	                var path = kp.replace(exprProp, '')
  	                var index
  	                var matches
  	                /**
  	                 * 1. mount.0
  	                 * 2. mount.0.0.prop
  	                 * 3. $value.prop
  	                 */
  	                if (exprProp == '$value' && (matches = path.match(/^\d+\.(\d+)(\.|$)/))) {
  	                    path = path.replace(/\d+\.?/, '')
  	                } else if (matches = path.match(/^\.(\d+)(\.|$)/)) {
  	                    path = path.replace(/^\./, '')
  	                } else {
  	                    return false
  	                }
  	                index = Number(matches[1])
  	                // can be delta update
  	                if (this.$vms && index < this.$vms.length) return {
  	                    index: index,
  	                    path:  path,
  	                    mount: exprProp
  	                }
  	                else return false
  	            },
  	            deltaUpdate: function (nextItems, preItems, kp, payload) {
  	                var index = payload.index
  	                var nv = nextItems[index]
  	                // delta update
  	                this._lastItems[index] = nv
  
  	                var $vm = this.$vms[index]
  	                updateVMData($vm, nv, index, payload.path)
  	            },
  	            update: function(items, preItems, kp, method, args) {
  	                if (!items || !items.forEach) {
  	                    return console.warn('"' + conf.namespace + 'repeat" only accept Array data. {' + this.expr + '}')
  	                }
  	                var that = this
  	                var valueOnly = Expression.variableOnly(this.$expr)
  	                
  	                // it's not modify
  	                if (valueOnly && method == 'splice' && args.length == 2 && (!args[1] || args[1] < 0)) return
  
  	                var $floor = this.$floor()
  	                var $ceil = this.$ceil()
  	                var arrayPatcher = {
  	                    splice: function () {
  	                        var ind = Number(args[0] || 0)
  	                        var len = Number(args[1] || 0)
  	                        var max = this.$vms.length
  	                        ind = ind > max ? max : ind
  	                        if (args.length > 2) {
  	                            /**
  	                             *  Insert
  	                             */
  	                            // create vms for each inserted item
  	                            var insertVms = [].slice.call(args, 2).map(function (item, index) {
  	                                return createSubVM.call(that, item, ind + index)
  	                            })
  	                            // insert items into current $vms
  	                            this.$vms.splice.apply(this.$vms, [ind, len].concat(insertVms))
  
  	                            // element bound for inserted item vm element
  	                            $(insertVms.map(function (vm) {
  	                                return vm.$compiler.$bundle()
  	                            })).insertAfter(
  	                                ind == 0 
  	                                ? $ceil
  	                                : this.$vms[ind - 1].$compiler.$bundle()
  	                            )
  	                            // get last update index
  	                            var start = ind + insertVms.length
  	                            this.$vms.forEach(function (vm, i) {
  	                                if (i >= start) {
  	                                    updateVMIndex(vm, i)
  	                                }
  	                            })
  
  	                        } else {
  	                            /**
  	                             *  remove
  	                             */
  	                            this.$vms.splice
  	                                     .apply(this.$vms, args)
  	                                     .forEach(function (vm, i) {
  	                                        destroyVM(vm)
  	                                     })
  
  	                            this.$vms.forEach(function (vm, i) {
  	                                if (i >= ind) {
  	                                    updateVMIndex(vm, i)
  	                                }
  	                            })
  	                        }
  	                    },
  	                    push: function () {
  	                        var index = items.length - 1
  	                        var vm = createSubVM.call(that, items[index], index)
  	                        this.$vms.push(vm)
  	                        vm.$compiler.$insertBefore($floor)
  	                    },
  	                    pop: function () {
  	                        var vm = this.$vms.pop()
  	                        destroyVM(vm)
  	                    },
  	                    shift: function () {
  	                        var vm = this.$vms.shift()
  	                        destroyVM(vm)
  	                        this.$vms.forEach(function (v, i) {
  	                            updateVMIndex(v, i)
  	                        })
  	                    },
  	                    unshift: function () {
  	                        var vm = createSubVM.call(that, items[0], 0)
  	                        this.$vms.unshift(vm)
  	                        vm.$compiler.$insertAfter($ceil)
  	                        this.$vms.forEach(function (v, i) {
  	                            if (i != 0) {
  	                                updateVMIndex(v, i)
  	                            }
  	                        })
  	                    },
  	                    $concat: function () {
  	                        var len = this.$vms.length
  	                        $(items.slice(len).map(function (item, i) {
  	                            var vm = createSubVM.call(that, item, i + len)
  	                            that.$vms.push(vm)
  	                            return vm.$compiler.$bundle()
  	                        })).insertBefore($floor)
  	                    }
  	                }
  
  	                var patch = arrayPatcher[method]
  	                if (valueOnly && this._noArrayFilter && patch) {
  	                    patch.call(this)
  	                    this._lastItems = util.copyArray(items)
  	                    return
  	                }
  	                /**
  	                 *  vms diff
  	                 */
  	                var vms = new Array(items.length)
  	                var olds = this._lastItems ? util.copyArray(this._lastItems) : olds
  	                var oldVms = this.$vms ? util.copyArray(this.$vms) : oldVms
  	                var source = this._lastItems 
  	                                ? this._lastItems.map(function (item) {
  	                                        return {
  	                                            data: item
  	                                        }
  	                                    })
  	                                : null
  
  	                var diffItems = items.map(function (item, index) {
  	                    var data = {
  	                        data: item
  	                    }
  	                    if (!source) {
  	                        data.status = 'created'
  	                    } else {
  	                        var i = -1
  	                        var dontUpdated
  	                        source.some(function (s, k) {
  	                            if (s.used) return
  
  	                            var hasDiff = util.diff(s.data, item)
  	                            if (!hasDiff) {
  	                                i = k
  	                                // and reuse the pos
  	                                if (index === i) return dontUpdated = true
  	                                else if (!~i) i = k
  	                            }
  	                        })
  	                        if (~i && dontUpdated) {
  	                            source[i].used = true
  	                            data.status = 'reused'
  	                        } else if (~i) {
  	                            source[i].used = true
  	                            data.status = 'moved'
  	                            data.from = i
  	                        } else {
  	                            source.some(function (s, k) {
  	                                if (!s.used && index == k) {
  	                                    i = k
  	                                    return true
  	                                }
  	                            })
  	                            if (~i) {
  	                                source[i].used = true
  	                                data.status = 'updated'
  	                                data.from = i
  	                            } else {
  	                                data.status = 'created'
  	                            }
  	                        }
  	                    }
  	                    return data
  	                })
  	                /**
  	                 * Patch
  	                 */
  	                source && source.forEach(function (item, index) {
  	                    if (!item.used) {
  	                        destroyVM(that.$vms[index])
  	                    }
  	                })
  	                var floor = $ceil
  	                this.$vms = diffItems.map(function (item, index) {
  	                    var vm
  	                    switch (item.status) {
  	                        case 'created':
  	                            if (source && source.some(function (item, ind) {
  	                                // reuse old vm
  	                                if (!item.used) {
  	                                    vm = that.$vms[ind]
  	                                    return true
  	                                }
  	                            })) {
  	                                updateVMData(vm, item.data, index, kp)
  	                            } else {
  	                                vm = createSubVM.call(that, item.data, index)
  	                            }
  	                            break
  	                        case 'updated':
  	                            vm = that.$vms[index]
  	                            updateVMData(vm, item.data, index, kp)
  	                            break
  	                        case 'moved':
  	                            vm = that.$vms[item.from]
  	                            updateVMIndex(vm, index)
  	                            break
  	                        case 'reused':
  	                            vm = that.$vms[index]
  	                            break
  	                    }
  	                    var $compiler = vm.$compiler
  	                    if (!$compiler.$preTo(floor)) {
  	                        vm.$compiler.$insertAfter(floor)
  	                    }
  	                    floor = $compiler.$floor()
  	                    return vm
  	                })
  	                // prevent data source changed
  	                this._lastItems = util.copyArray(items)
  	            }
  	        }
  	    }
  	}
  	function shallowClone (data) {
  	    return util.type(data) == 'object' ? util.copyObject(data) : {}
  	}
  	// function RepeatViewModel (el, data, index, parentVM, parentScope) {
  	//     data = shallowClone(data)
  	//     data.$index = index
  	//     data.$value = data
  	//     var $scope = new Scope(data, parentScope)
  	//     // on the top of current scope
  	//     parentScope && parentScope.children.push($scope)
  	//     this.$index = index
  	//     this.$value = data
  	//     this.$compiler = parentVM.$compile(el, $scope)
  	//     this.$scope = $scope
  	// }
  	/**
  	 *  create a sub-vm for array item with specified index
  	 */
  	function createSubVM (item, index) {
  	    var subEl = this.child.cloneNode(true)
  	    var data = shallowClone(item)
  
  	    data.$index = index
  	    data.$value = item
  
  	    var $scope = new Scope(data, this.$scope)
  	    // this.$scope is a parent scope, 
  	    // on the top of current scope
  	    if(this.$scope) {
  	        this.$scope.children.push($scope)
  	    }
  	    return {
  	        $index: index,
  	        $value: item,
  	        $compiler: this.$vm.$compile(subEl, $scope),
  	        $scope: $scope
  	    }
  	}
  	function updateVMData (vm, data, index, mounted) {
  	    // next time will add props to data object
  	    var $data = vm.$scope.data = shallowClone(data)
  	    $data.$index = index
  	    $data.$value = data
  
  	    vm.$value = data
  	    vm.$index = index
  	    vm.$scope.$update(mounted || '')
  	}
  	function updateVMIndex (vm, index) {
  	    vm.$index = index
  	    var $data = vm.$scope.data
  	    $data.$index = index
  	    vm.$scope.$update()
  	}
  	function destroyVM (vm) {
  	    var $parent = vm.$scope.$parent
  	    $parent && $parent.$removeChild(vm.$scope)
  	    // $compiler be inclued in $scope.bindings probably
  	    vm.$compiler.$remove().$destroy()
  	    vm.$scope.bindings.forEach(function (bd) {
  	        bd.$destroy()
  	    })                    
  	}
  
  /***/ },
  /* 12 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 *  Scope abstraction is a colletor when compiler child template with scope 
  	 */
  
  	'use strict';
  
  	function Scope (data, parent) {
  	    this.data = data
  	    this.bindings = []
  	    this.children = []
  	    this.$parent = parent || null
  	}
  
  	Scope.prototype.$update = function () {
  	    var args = arguments
  	    this.bindings.forEach(function (bd) {
  	        bd.$update.apply(bd, args)
  	    })
  	    this.children.forEach(function (child) {
  	        child.$update.apply(child, args)
  	    })
  	}
  	Scope.prototype.$removeChild = function (scope) {
  	    var i = this.children.indexOf(scope)
  	    if (~i) {
  	        scope.$parent = null
  	        this.children.splice(i, 1)
  	    }
  	    return this
  	}
  	Scope.prototype.$addChild = function (scope) {
  	    if (!~this.children.indexOf(scope)) this.children.push(scope)
  	    return this
  	}
  
  	module.exports = Scope
  
  /***/ }
  /******/ ])
  });
  ;