text: webpackJsonp([2],{
  
  /***/ 618:
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(619), __esModule: true };
  
  /***/ },
  
  /***/ 619:
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(338);
  	__webpack_require__(310);
  	__webpack_require__(322);
  	__webpack_require__(620);
  	module.exports = __webpack_require__(263).Promise;
  
  /***/ },
  
  /***/ 620:
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	var LIBRARY            = __webpack_require__(313)
  	  , global             = __webpack_require__(262)
  	  , ctx                = __webpack_require__(264)
  	  , classof            = __webpack_require__(621)
  	  , $export            = __webpack_require__(261)
  	  , isObject           = __webpack_require__(269)
  	  , aFunction          = __webpack_require__(265)
  	  , anInstance         = __webpack_require__(622)
  	  , forOf              = __webpack_require__(623)
  	  , speciesConstructor = __webpack_require__(627)
  	  , task               = __webpack_require__(628).set
  	  , microtask          = __webpack_require__(630)()
  	  , PROMISE            = 'Promise'
  	  , TypeError          = global.TypeError
  	  , process            = global.process
  	  , $Promise           = global[PROMISE]
  	  , process            = global.process
  	  , isNode             = classof(process) == 'process'
  	  , empty              = function(){ /* empty */ }
  	  , Internal, GenericPromiseCapability, Wrapper;
  	
  	var USE_NATIVE = !!function(){
  	  try {
  	    // correct subclassing with @@species support
  	    var promise     = $Promise.resolve(1)
  	      , FakePromise = (promise.constructor = {})[__webpack_require__(321)('species')] = function(exec){ exec(empty, empty); };
  	    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
  	    return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;
  	  } catch(e){ /* empty */ }
  	}();
  	
  	// helpers
  	var sameConstructor = function(a, b){
  	  // with library wrapper special case
  	  return a === b || a === $Promise && b === Wrapper;
  	};
  	var isThenable = function(it){
  	  var then;
  	  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
  	};
  	var newPromiseCapability = function(C){
  	  return sameConstructor($Promise, C)
  	    ? new PromiseCapability(C)
  	    : new GenericPromiseCapability(C);
  	};
  	var PromiseCapability = GenericPromiseCapability = function(C){
  	  var resolve, reject;
  	  this.promise = new C(function($$resolve, $$reject){
  	    if(resolve !== undefined || reject !== undefined)throw TypeError('Bad Promise constructor');
  	    resolve = $$resolve;
  	    reject  = $$reject;
  	  });
  	  this.resolve = aFunction(resolve);
  	  this.reject  = aFunction(reject);
  	};
  	var perform = function(exec){
  	  try {
  	    exec();
  	  } catch(e){
  	    return {error: e};
  	  }
  	};
  	var notify = function(promise, isReject){
  	  if(promise._n)return;
  	  promise._n = true;
  	  var chain = promise._c;
  	  microtask(function(){
  	    var value = promise._v
  	      , ok    = promise._s == 1
  	      , i     = 0;
  	    var run = function(reaction){
  	      var handler = ok ? reaction.ok : reaction.fail
  	        , resolve = reaction.resolve
  	        , reject  = reaction.reject
  	        , domain  = reaction.domain
  	        , result, then;
  	      try {
  	        if(handler){
  	          if(!ok){
  	            if(promise._h == 2)onHandleUnhandled(promise);
  	            promise._h = 1;
  	          }
  	          if(handler === true)result = value;
  	          else {
  	            if(domain)domain.enter();
  	            result = handler(value);
  	            if(domain)domain.exit();
  	          }
  	          if(result === reaction.promise){
  	            reject(TypeError('Promise-chain cycle'));
  	          } else if(then = isThenable(result)){
  	            then.call(result, resolve, reject);
  	          } else resolve(result);
  	        } else reject(value);
  	      } catch(e){
  	        reject(e);
  	      }
  	    };
  	    while(chain.length > i)run(chain[i++]); // variable length - can't use forEach
  	    promise._c = [];
  	    promise._n = false;
  	    if(isReject && !promise._h)onUnhandled(promise);
  	  });
  	};
  	var onUnhandled = function(promise){
  	  task.call(global, function(){
  	    var value = promise._v
  	      , abrupt, handler, console;
  	    if(isUnhandled(promise)){
  	      abrupt = perform(function(){
  	        if(isNode){
  	          process.emit('unhandledRejection', value, promise);
  	        } else if(handler = global.onunhandledrejection){
  	          handler({promise: promise, reason: value});
  	        } else if((console = global.console) && console.error){
  	          console.error('Unhandled promise rejection', value);
  	        }
  	      });
  	      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
  	      promise._h = isNode || isUnhandled(promise) ? 2 : 1;
  	    } promise._a = undefined;
  	    if(abrupt)throw abrupt.error;
  	  });
  	};
  	var isUnhandled = function(promise){
  	  if(promise._h == 1)return false;
  	  var chain = promise._a || promise._c
  	    , i     = 0
  	    , reaction;
  	  while(chain.length > i){
  	    reaction = chain[i++];
  	    if(reaction.fail || !isUnhandled(reaction.promise))return false;
  	  } return true;
  	};
  	var onHandleUnhandled = function(promise){
  	  task.call(global, function(){
  	    var handler;
  	    if(isNode){
  	      process.emit('rejectionHandled', promise);
  	    } else if(handler = global.onrejectionhandled){
  	      handler({promise: promise, reason: promise._v});
  	    }
  	  });
  	};
  	var $reject = function(value){
  	  var promise = this;
  	  if(promise._d)return;
  	  promise._d = true;
  	  promise = promise._w || promise; // unwrap
  	  promise._v = value;
  	  promise._s = 2;
  	  if(!promise._a)promise._a = promise._c.slice();
  	  notify(promise, true);
  	};
  	var $resolve = function(value){
  	  var promise = this
  	    , then;
  	  if(promise._d)return;
  	  promise._d = true;
  	  promise = promise._w || promise; // unwrap
  	  try {
  	    if(promise === value)throw TypeError("Promise can't be resolved itself");
  	    if(then = isThenable(value)){
  	      microtask(function(){
  	        var wrapper = {_w: promise, _d: false}; // wrap
  	        try {
  	          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
  	        } catch(e){
  	          $reject.call(wrapper, e);
  	        }
  	      });
  	    } else {
  	      promise._v = value;
  	      promise._s = 1;
  	      notify(promise, false);
  	    }
  	  } catch(e){
  	    $reject.call({_w: promise, _d: false}, e); // wrap
  	  }
  	};
  	
  	// constructor polyfill
  	if(!USE_NATIVE){
  	  // 25.4.3.1 Promise(executor)
  	  $Promise = function Promise(executor){
  	    anInstance(this, $Promise, PROMISE, '_h');
  	    aFunction(executor);
  	    Internal.call(this);
  	    try {
  	      executor(ctx($resolve, this, 1), ctx($reject, this, 1));
  	    } catch(err){
  	      $reject.call(this, err);
  	    }
  	  };
  	  Internal = function Promise(executor){
  	    this._c = [];             // <- awaiting reactions
  	    this._a = undefined;      // <- checked in isUnhandled reactions
  	    this._s = 0;              // <- state
  	    this._d = false;          // <- done
  	    this._v = undefined;      // <- value
  	    this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
  	    this._n = false;          // <- notify
  	  };
  	  Internal.prototype = __webpack_require__(631)($Promise.prototype, {
  	    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
  	    then: function then(onFulfilled, onRejected){
  	      var reaction    = newPromiseCapability(speciesConstructor(this, $Promise));
  	      reaction.ok     = typeof onFulfilled == 'function' ? onFulfilled : true;
  	      reaction.fail   = typeof onRejected == 'function' && onRejected;
  	      reaction.domain = isNode ? process.domain : undefined;
  	      this._c.push(reaction);
  	      if(this._a)this._a.push(reaction);
  	      if(this._s)notify(this, false);
  	      return reaction.promise;
  	    },
  	    // 25.4.5.1 Promise.prototype.catch(onRejected)
  	    'catch': function(onRejected){
  	      return this.then(undefined, onRejected);
  	    }
  	  });
  	  PromiseCapability = function(){
  	    var promise  = new Internal;
  	    this.promise = promise;
  	    this.resolve = ctx($resolve, promise, 1);
  	    this.reject  = ctx($reject, promise, 1);
  	  };
  	}
  	
  	$export($export.G + $export.W + $export.F * !USE_NATIVE, {Promise: $Promise});
  	__webpack_require__(320)($Promise, PROMISE);
  	__webpack_require__(632)(PROMISE);
  	Wrapper = __webpack_require__(263)[PROMISE];
  	
  	// statics
  	$export($export.S + $export.F * !USE_NATIVE, PROMISE, {
  	  // 25.4.4.5 Promise.reject(r)
  	  reject: function reject(r){
  	    var capability = newPromiseCapability(this)
  	      , $$reject   = capability.reject;
  	    $$reject(r);
  	    return capability.promise;
  	  }
  	});
  	$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
  	  // 25.4.4.6 Promise.resolve(x)
  	  resolve: function resolve(x){
  	    // instanceof instead of internal slot check because we should fix it without replacement native Promise core
  	    if(x instanceof $Promise && sameConstructor(x.constructor, this))return x;
  	    var capability = newPromiseCapability(this)
  	      , $$resolve  = capability.resolve;
  	    $$resolve(x);
  	    return capability.promise;
  	  }
  	});
  	$export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(633)(function(iter){
  	  $Promise.all(iter)['catch'](empty);
  	})), PROMISE, {
  	  // 25.4.4.1 Promise.all(iterable)
  	  all: function all(iterable){
  	    var C          = this
  	      , capability = newPromiseCapability(C)
  	      , resolve    = capability.resolve
  	      , reject     = capability.reject;
  	    var abrupt = perform(function(){
  	      var values    = []
  	        , index     = 0
  	        , remaining = 1;
  	      forOf(iterable, false, function(promise){
  	        var $index        = index++
  	          , alreadyCalled = false;
  	        values.push(undefined);
  	        remaining++;
  	        C.resolve(promise).then(function(value){
  	          if(alreadyCalled)return;
  	          alreadyCalled  = true;
  	          values[$index] = value;
  	          --remaining || resolve(values);
  	        }, reject);
  	      });
  	      --remaining || resolve(values);
  	    });
  	    if(abrupt)reject(abrupt.error);
  	    return capability.promise;
  	  },
  	  // 25.4.4.4 Promise.race(iterable)
  	  race: function race(iterable){
  	    var C          = this
  	      , capability = newPromiseCapability(C)
  	      , reject     = capability.reject;
  	    var abrupt = perform(function(){
  	      forOf(iterable, false, function(promise){
  	        C.resolve(promise).then(capability.resolve, reject);
  	      });
  	    });
  	    if(abrupt)reject(abrupt.error);
  	    return capability.promise;
  	  }
  	});
  
  /***/ },
  
  /***/ 621:
  /***/ function(module, exports, __webpack_require__) {
  
  	// getting tag from 19.1.3.6 Object.prototype.toString()
  	var cof = __webpack_require__(282)
  	  , TAG = __webpack_require__(321)('toStringTag')
  	  // ES3 wrong here
  	  , ARG = cof(function(){ return arguments; }()) == 'Arguments';
  	
  	// fallback for IE11 Script Access Denied error
  	var tryGet = function(it, key){
  	  try {
  	    return it[key];
  	  } catch(e){ /* empty */ }
  	};
  	
  	module.exports = function(it){
  	  var O, T, B;
  	  return it === undefined ? 'Undefined' : it === null ? 'Null'
  	    // @@toStringTag case
  	    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
  	    // builtinTag case
  	    : ARG ? cof(O)
  	    // ES3 arguments fallback
  	    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
  	};
  
  /***/ },
  
  /***/ 622:
  /***/ function(module, exports) {
  
  	module.exports = function(it, Constructor, name, forbiddenField){
  	  if(!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)){
  	    throw TypeError(name + ': incorrect invocation!');
  	  } return it;
  	};
  
  /***/ },
  
  /***/ 623:
  /***/ function(module, exports, __webpack_require__) {
  
  	var ctx         = __webpack_require__(264)
  	  , call        = __webpack_require__(624)
  	  , isArrayIter = __webpack_require__(625)
  	  , anObject    = __webpack_require__(268)
  	  , toLength    = __webpack_require__(285)
  	  , getIterFn   = __webpack_require__(626)
  	  , BREAK       = {}
  	  , RETURN      = {};
  	var exports = module.exports = function(iterable, entries, fn, that, ITERATOR){
  	  var iterFn = ITERATOR ? function(){ return iterable; } : getIterFn(iterable)
  	    , f      = ctx(fn, that, entries ? 2 : 1)
  	    , index  = 0
  	    , length, step, iterator, result;
  	  if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');
  	  // fast case for arrays with default iterator
  	  if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){
  	    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
  	    if(result === BREAK || result === RETURN)return result;
  	  } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){
  	    result = call(iterator, f, step.value, entries);
  	    if(result === BREAK || result === RETURN)return result;
  	  }
  	};
  	exports.BREAK  = BREAK;
  	exports.RETURN = RETURN;
  
  /***/ },
  
  /***/ 624:
  /***/ function(module, exports, __webpack_require__) {
  
  	// call something on iterator step with safe closing on error
  	var anObject = __webpack_require__(268);
  	module.exports = function(iterator, fn, value, entries){
  	  try {
  	    return entries ? fn(anObject(value)[0], value[1]) : fn(value);
  	  // 7.4.6 IteratorClose(iterator, completion)
  	  } catch(e){
  	    var ret = iterator['return'];
  	    if(ret !== undefined)anObject(ret.call(iterator));
  	    throw e;
  	  }
  	};
  
  /***/ },
  
  /***/ 625:
  /***/ function(module, exports, __webpack_require__) {
  
  	// check on default Array iterator
  	var Iterators  = __webpack_require__(315)
  	  , ITERATOR   = __webpack_require__(321)('iterator')
  	  , ArrayProto = Array.prototype;
  	
  	module.exports = function(it){
  	  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
  	};
  
  /***/ },
  
  /***/ 626:
  /***/ function(module, exports, __webpack_require__) {
  
  	var classof   = __webpack_require__(621)
  	  , ITERATOR  = __webpack_require__(321)('iterator')
  	  , Iterators = __webpack_require__(315);
  	module.exports = __webpack_require__(263).getIteratorMethod = function(it){
  	  if(it != undefined)return it[ITERATOR]
  	    || it['@@iterator']
  	    || Iterators[classof(it)];
  	};
  
  /***/ },
  
  /***/ 627:
  /***/ function(module, exports, __webpack_require__) {
  
  	// 7.3.20 SpeciesConstructor(O, defaultConstructor)
  	var anObject  = __webpack_require__(268)
  	  , aFunction = __webpack_require__(265)
  	  , SPECIES   = __webpack_require__(321)('species');
  	module.exports = function(O, D){
  	  var C = anObject(O).constructor, S;
  	  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
  	};
  
  /***/ },
  
  /***/ 628:
  /***/ function(module, exports, __webpack_require__) {
  
  	var ctx                = __webpack_require__(264)
  	  , invoke             = __webpack_require__(629)
  	  , html               = __webpack_require__(319)
  	  , cel                = __webpack_require__(273)
  	  , global             = __webpack_require__(262)
  	  , process            = global.process
  	  , setTask            = global.setImmediate
  	  , clearTask          = global.clearImmediate
  	  , MessageChannel     = global.MessageChannel
  	  , counter            = 0
  	  , queue              = {}
  	  , ONREADYSTATECHANGE = 'onreadystatechange'
  	  , defer, channel, port;
  	var run = function(){
  	  var id = +this;
  	  if(queue.hasOwnProperty(id)){
  	    var fn = queue[id];
  	    delete queue[id];
  	    fn();
  	  }
  	};
  	var listener = function(event){
  	  run.call(event.data);
  	};
  	// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
  	if(!setTask || !clearTask){
  	  setTask = function setImmediate(fn){
  	    var args = [], i = 1;
  	    while(arguments.length > i)args.push(arguments[i++]);
  	    queue[++counter] = function(){
  	      invoke(typeof fn == 'function' ? fn : Function(fn), args);
  	    };
  	    defer(counter);
  	    return counter;
  	  };
  	  clearTask = function clearImmediate(id){
  	    delete queue[id];
  	  };
  	  // Node.js 0.8-
  	  if(__webpack_require__(282)(process) == 'process'){
  	    defer = function(id){
  	      process.nextTick(ctx(run, id, 1));
  	    };
  	  // Browsers with MessageChannel, includes WebWorkers
  	  } else if(MessageChannel){
  	    channel = new MessageChannel;
  	    port    = channel.port2;
  	    channel.port1.onmessage = listener;
  	    defer = ctx(port.postMessage, port, 1);
  	  // Browsers with postMessage, skip WebWorkers
  	  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
  	  } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){
  	    defer = function(id){
  	      global.postMessage(id + '', '*');
  	    };
  	    global.addEventListener('message', listener, false);
  	  // IE8-
  	  } else if(ONREADYSTATECHANGE in cel('script')){
  	    defer = function(id){
  	      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){
  	        html.removeChild(this);
  	        run.call(id);
  	      };
  	    };
  	  // Rest old browsers
  	  } else {
  	    defer = function(id){
  	      setTimeout(ctx(run, id, 1), 0);
  	    };
  	  }
  	}
  	module.exports = {
  	  set:   setTask,
  	  clear: clearTask
  	};
  
  /***/ },
  
  /***/ 629:
  /***/ function(module, exports) {
  
  	// fast apply, http://jsperf.lnkit.com/fast-apply/5
  	module.exports = function(fn, args, that){
  	  var un = that === undefined;
  	  switch(args.length){
  	    case 0: return un ? fn()
  	                      : fn.call(that);
  	    case 1: return un ? fn(args[0])
  	                      : fn.call(that, args[0]);
  	    case 2: return un ? fn(args[0], args[1])
  	                      : fn.call(that, args[0], args[1]);
  	    case 3: return un ? fn(args[0], args[1], args[2])
  	                      : fn.call(that, args[0], args[1], args[2]);
  	    case 4: return un ? fn(args[0], args[1], args[2], args[3])
  	                      : fn.call(that, args[0], args[1], args[2], args[3]);
  	  } return              fn.apply(that, args);
  	};
  
  /***/ },
  
  /***/ 630:
  /***/ function(module, exports, __webpack_require__) {
  
  	var global    = __webpack_require__(262)
  	  , macrotask = __webpack_require__(628).set
  	  , Observer  = global.MutationObserver || global.WebKitMutationObserver
  	  , process   = global.process
  	  , Promise   = global.Promise
  	  , isNode    = __webpack_require__(282)(process) == 'process';
  	
  	module.exports = function(){
  	  var head, last, notify;
  	
  	  var flush = function(){
  	    var parent, fn;
  	    if(isNode && (parent = process.domain))parent.exit();
  	    while(head){
  	      fn   = head.fn;
  	      head = head.next;
  	      try {
  	        fn();
  	      } catch(e){
  	        if(head)notify();
  	        else last = undefined;
  	        throw e;
  	      }
  	    } last = undefined;
  	    if(parent)parent.enter();
  	  };
  	
  	  // Node.js
  	  if(isNode){
  	    notify = function(){
  	      process.nextTick(flush);
  	    };
  	  // browsers with MutationObserver
  	  } else if(Observer){
  	    var toggle = true
  	      , node   = document.createTextNode('');
  	    new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new
  	    notify = function(){
  	      node.data = toggle = !toggle;
  	    };
  	  // environments with maybe non-completely correct, but existent Promise
  	  } else if(Promise && Promise.resolve){
  	    var promise = Promise.resolve();
  	    notify = function(){
  	      promise.then(flush);
  	    };
  	  // for other environments - macrotask based on:
  	  // - setImmediate
  	  // - MessageChannel
  	  // - window.postMessag
  	  // - onreadystatechange
  	  // - setTimeout
  	  } else {
  	    notify = function(){
  	      // strange IE + webpack dev server bug - use .call(global)
  	      macrotask.call(global, flush);
  	    };
  	  }
  	
  	  return function(fn){
  	    var task = {fn: fn, next: undefined};
  	    if(last)last.next = task;
  	    if(!head){
  	      head = task;
  	      notify();
  	    } last = task;
  	  };
  	};
  
  /***/ },
  
  /***/ 631:
  /***/ function(module, exports, __webpack_require__) {
  
  	var hide = __webpack_require__(266);
  	module.exports = function(target, src, safe){
  	  for(var key in src){
  	    if(safe && target[key])target[key] = src[key];
  	    else hide(target, key, src[key]);
  	  } return target;
  	};
  
  /***/ },
  
  /***/ 632:
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	var global      = __webpack_require__(262)
  	  , core        = __webpack_require__(263)
  	  , dP          = __webpack_require__(267)
  	  , DESCRIPTORS = __webpack_require__(271)
  	  , SPECIES     = __webpack_require__(321)('species');
  	
  	module.exports = function(KEY){
  	  var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];
  	  if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {
  	    configurable: true,
  	    get: function(){ return this; }
  	  });
  	};
  
  /***/ },
  
  /***/ 633:
  /***/ function(module, exports, __webpack_require__) {
  
  	var ITERATOR     = __webpack_require__(321)('iterator')
  	  , SAFE_CLOSING = false;
  	
  	try {
  	  var riter = [7][ITERATOR]();
  	  riter['return'] = function(){ SAFE_CLOSING = true; };
  	  Array.from(riter, function(){ throw 2; });
  	} catch(e){ /* empty */ }
  	
  	module.exports = function(exec, skipClosing){
  	  if(!skipClosing && !SAFE_CLOSING)return false;
  	  var safe = false;
  	  try {
  	    var arr  = [7]
  	      , iter = arr[ITERATOR]();
  	    iter.next = function(){ return {done: safe = true}; };
  	    arr[ITERATOR] = function(){ return iter; };
  	    exec(arr);
  	  } catch(e){ /* empty */ }
  	  return safe;
  	};
  
  /***/ },
  
  /***/ 671:
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	
  	var _Counter = __webpack_require__(672);
  	
  	var _Counter2 = _interopRequireDefault(_Counter);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	exports.default = _Counter2.default;
  
  /***/ },
  
  /***/ 672:
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	exports.Counter = undefined;
  	
  	var _react = __webpack_require__(2);
  	
  	var _react2 = _interopRequireDefault(_react);
  	
  	var _Counter = __webpack_require__(673);
  	
  	var _Counter2 = _interopRequireDefault(_Counter);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	var Counter = exports.Counter = function Counter(props) {
  	  return _react2.default.createElement(
  	    'div',
  	    null,
  	    _react2.default.createElement(
  	      'h2',
  	      { className: _Counter2.default.counterContainer },
  	      'Counter:',
  	      ' ',
  	      _react2.default.createElement(
  	        'span',
  	        { className: _Counter2.default['counter--green'] },
  	        props.counter
  	      )
  	    ),
  	    _react2.default.createElement(
  	      'button',
  	      { className: 'btn btn-default', onClick: props.increment },
  	      'Increment'
  	    ),
  	    ' ',
  	    _react2.default.createElement(
  	      'button',
  	      { className: 'btn btn-default', onClick: props.doubleAsync },
  	      'Double (Async)'
  	    )
  	  );
  	};
  	
  	Counter.propTypes = {
  	  counter: _react2.default.PropTypes.number.isRequired,
  	  doubleAsync: _react2.default.PropTypes.func.isRequired,
  	  increment: _react2.default.PropTypes.func.isRequired
  	};
  	
  	exports.default = Counter;
  
  /***/ },
  
  /***/ 673:
  /***/ function(module, exports, __webpack_require__) {
  
  	// style-loader: Adds some css to the DOM by adding a <style> tag
  	
  	// load the styles
  	var content = __webpack_require__(674);
  	if(typeof content === 'string') content = [[module.id, content, '']];
  	// add the styles to the DOM
  	var update = __webpack_require__(576)(content, {});
  	if(content.locals) module.exports = content.locals;
  	// Hot Module Replacement
  	if(true) {
  		// When the styles change, update the <style> tags
  		if(!content.locals) {
  			module.hot.accept(674, function() {
  				var newContent = __webpack_require__(674);
  				if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
  				update(newContent);
  			});
  		}
  		// When the module is disposed, remove the <style> tags
  		module.hot.dispose(function() { update(); });
  	}
  
  /***/ },
  
  /***/ 674:
  /***/ function(module, exports, __webpack_require__) {
  
  	exports = module.exports = __webpack_require__(575)();
  	// imports
  	
  	
  	// module
  	exports.push([module.id, ".Counter__counter___8Lvk1{font-weight:700}.Counter__counter--green___30k-8{color:#19c819}.Counter__counterContainer___1Ev3K{margin:1em auto}", "", {"version":3,"sources":["/./src/components/Counter/src/components/Counter/Counter.scss"],"names":[],"mappings":"AAAA,0BACE,eAAkB,CACnB,iCAGmB,aACR,CACX,mCAGC,eAAiB,CAClB","file":"Counter.scss","sourcesContent":[".counter {\n  font-weight: bold;\n}\n\n.counter--green {\n  composes: counter;\n  color: rgb(25,200,25);\n}\n\n.counterContainer {\n  margin: 1em auto;\n}\n"],"sourceRoot":"webpack://"}]);
  	
  	// exports
  	exports.locals = {
  		"counter": "Counter__counter___8Lvk1",
  		"counter--green": "Counter__counter--green___30k-8 Counter__counter___8Lvk1",
  		"counterContainer": "Counter__counterContainer___1Ev3K"
  	};
  
  /***/ },
  
  /***/ 774:
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	    value: true
  	});
  	
  	var _reactRedux = __webpack_require__(349);
  	
  	var _counter = __webpack_require__(775);
  	
  	var _Counter = __webpack_require__(671);
  	
  	var _Counter2 = _interopRequireDefault(_Counter);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	/*  Object of action creators (can also be function that returns object).
  	    Keys will be passed as props to presentational components. Here we are
  	    implementing our wrapper around increment; the component doesn't care   */
  	
  	var mapActionCreators = {
  	    increment: function increment() {
  	        return (0, _counter.increment)(1);
  	    },
  	    doubleAsync: _counter.doubleAsync
  	};
  	
  	/*  This is a container component. Notice it does not contain any JSX,
  	    nor does it import React. This component is **only** responsible for
  	    wiring in the actions and state necessary to render a presentational
  	    component - in this case, the counter:   */
  	
  	var mapStateToProps = function mapStateToProps(state) {
  	    return {
  	        counter: state.counter
  	    };
  	};
  	
  	/*  Note: mapStateToProps is where you should use `reselect` to create selectors, ie:
  	
  	    import { createSelector } from 'reselect'
  	    const counter = (state) => state.counter
  	    const tripleCount = createSelector(counter, (count) => count * 3)
  	    const mapStateToProps = (state) => ({
  	      counter: tripleCount(state)
  	    })
  	
  	    Selectors can compute derived data, allowing Redux to store the minimal possible state.
  	    Selectors are efficient. A selector is not recomputed unless one of its arguments change.
  	    Selectors are composable. They can be used as input to other selectors.
  	    https://github.com/reactjs/reselect    */
  	
  	exports.default = (0, _reactRedux.connect)(mapStateToProps, mapActionCreators)(_Counter2.default);
  
  /***/ },
  
  /***/ 775:
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	exports.actions = exports.doubleAsync = exports.COUNTER_INCREMENT = undefined;
  	
  	var _defineProperty2 = __webpack_require__(525);
  	
  	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
  	
  	var _promise = __webpack_require__(618);
  	
  	var _promise2 = _interopRequireDefault(_promise);
  	
  	exports.increment = increment;
  	exports.default = counterReducer;
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	// ------------------------------------
  	// Constants
  	// ------------------------------------
  	var COUNTER_INCREMENT = exports.COUNTER_INCREMENT = 'COUNTER_INCREMENT';
  	
  	// ------------------------------------
  	// Actions
  	// ------------------------------------
  	function increment() {
  	  var value = arguments.length <= 0 || arguments[0] === undefined ? 1 : arguments[0];
  	
  	  return {
  	    type: COUNTER_INCREMENT,
  	    payload: value
  	  };
  	}
  	
  	/*  This is a thunk, meaning it is a function that immediately
  	    returns a function for lazy evaluation. It is incredibly useful for
  	    creating async actions, especially when combined with redux-thunk!
  	
  	    NOTE: This is solely for demonstration purposes. In a real application,
  	    you'd probably want to dispatch an action of COUNTER_DOUBLE and let the
  	    reducer take care of this logic.  */
  	
  	var doubleAsync = exports.doubleAsync = function doubleAsync() {
  	  return function (dispatch, getState) {
  	    return new _promise2.default(function (resolve) {
  	      setTimeout(function () {
  	        dispatch(increment(getState().counter));
  	        resolve();
  	      }, 2000);
  	    });
  	  };
  	};
  	
  	var actions = exports.actions = {
  	  increment: increment,
  	  doubleAsync: doubleAsync
  	};
  	
  	// ------------------------------------
  	// Action Handlers
  	// ------------------------------------
  	var ACTION_HANDLERS = (0, _defineProperty3.default)({}, COUNTER_INCREMENT, function (state, action) {
  	  return state + action.payload;
  	});
  	
  	// ------------------------------------
  	// Reducer
  	// ------------------------------------
  	var initialState = 2;
  	function counterReducer() {
  	  var state = arguments.length <= 0 || arguments[0] === undefined ? initialState : arguments[0];
  	  var action = arguments[1];
  	
  	  var handler = ACTION_HANDLERS[action.type];
  	  return handler ? handler(state, action) : state;
  	}
  
  /***/ }
  
  });
  //# sourceMappingURL=2.counter.d107b1e81ba5c991cfe8.js.map