text: webpackJsonp([0,5],[
  /* 0 */,
  /* 1 */,
  /* 2 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var isObject = __webpack_require__(8);
  module.exports = function(it){
    if(!isObject(it))throw TypeError(it + ' is not an object!');
    return it;
  };
  
  /***/ }),
  /* 3 */,
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var global    = __webpack_require__(12)
    , core      = __webpack_require__(31)
    , hide      = __webpack_require__(42)
    , redefine  = __webpack_require__(34)
    , ctx       = __webpack_require__(32)
    , PROTOTYPE = 'prototype';
  
  var $export = function(type, name, source){
    var IS_FORCED = type & $export.F
      , IS_GLOBAL = type & $export.G
      , IS_STATIC = type & $export.S
      , IS_PROTO  = type & $export.P
      , IS_BIND   = type & $export.B
      , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]
      , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
      , expProto  = exports[PROTOTYPE] || (exports[PROTOTYPE] = {})
      , key, own, out, exp;
    if(IS_GLOBAL)source = name;
    for(key in source){
      // contains in native
      own = !IS_FORCED && target && target[key] !== undefined;
      // export native or passed
      out = (own ? target : source)[key];
      // bind timers to global for call from export context
      exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
      // extend global
      if(target)redefine(target, key, out, type & $export.U);
      // export
      if(exports[key] != out)hide(exports, key, exp);
      if(IS_PROTO && expProto[key] != out)expProto[key] = out;
    }
  };
  global.core = core;
  // type bitmap
  $export.F = 1;   // forced
  $export.G = 2;   // global
  $export.S = 4;   // static
  $export.P = 8;   // proto
  $export.B = 16;  // bind
  $export.W = 32;  // wrap
  $export.U = 64;  // safe
  $export.R = 128; // real proto method for `library` 
  module.exports = $export;
  
  /***/ }),
  /* 5 */,
  /* 6 */,
  /* 7 */,
  /* 8 */
  /***/ (function(module, exports) {
  
  module.exports = function(it){
    return typeof it === 'object' ? it !== null : typeof it === 'function';
  };
  
  /***/ }),
  /* 9 */,
  /* 10 */,
  /* 11 */,
  /* 12 */
  /***/ (function(module, exports) {
  
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
  var global = module.exports = typeof window != 'undefined' && window.Math == Math
    ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
  if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
  
  /***/ }),
  /* 13 */,
  /* 14 */
  /***/ (function(module, exports) {
  
  var hasOwnProperty = {}.hasOwnProperty;
  module.exports = function(it, key){
    return hasOwnProperty.call(it, key);
  };
  
  /***/ }),
  /* 15 */,
  /* 16 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var Map     = __webpack_require__(251)
    , $export = __webpack_require__(4)
    , shared  = __webpack_require__(77)('metadata')
    , store   = shared.store || (shared.store = new (__webpack_require__(267)));
  
  var getOrCreateMetadataMap = function(target, targetKey, create){
    var targetMetadata = store.get(target);
    if(!targetMetadata){
      if(!create)return undefined;
      store.set(target, targetMetadata = new Map);
    }
    var keyMetadata = targetMetadata.get(targetKey);
    if(!keyMetadata){
      if(!create)return undefined;
      targetMetadata.set(targetKey, keyMetadata = new Map);
    } return keyMetadata;
  };
  var ordinaryHasOwnMetadata = function(MetadataKey, O, P){
    var metadataMap = getOrCreateMetadataMap(O, P, false);
    return metadataMap === undefined ? false : metadataMap.has(MetadataKey);
  };
  var ordinaryGetOwnMetadata = function(MetadataKey, O, P){
    var metadataMap = getOrCreateMetadataMap(O, P, false);
    return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey);
  };
  var ordinaryDefineOwnMetadata = function(MetadataKey, MetadataValue, O, P){
    getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue);
  };
  var ordinaryOwnMetadataKeys = function(target, targetKey){
    var metadataMap = getOrCreateMetadataMap(target, targetKey, false)
      , keys        = [];
    if(metadataMap)metadataMap.forEach(function(_, key){ keys.push(key); });
    return keys;
  };
  var toMetaKey = function(it){
    return it === undefined || typeof it == 'symbol' ? it : String(it);
  };
  var exp = function(O){
    $export($export.S, 'Reflect', O);
  };
  
  module.exports = {
    store: store,
    map: getOrCreateMetadataMap,
    has: ordinaryHasOwnMetadata,
    get: ordinaryGetOwnMetadata,
    set: ordinaryDefineOwnMetadata,
    keys: ordinaryOwnMetadataKeys,
    key: toMetaKey,
    exp: exp
  };
  
  /***/ }),
  /* 17 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var store      = __webpack_require__(77)('wks')
    , uid        = __webpack_require__(45)
    , Symbol     = __webpack_require__(12).Symbol
    , USE_SYMBOL = typeof Symbol == 'function';
  
  var $exports = module.exports = function(name){
    return store[name] || (store[name] =
      USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
  };
  
  $exports.store = store;
  
  /***/ }),
  /* 18 */,
  /* 19 */,
  /* 20 */
  /***/ (function(module, exports) {
  
  module.exports = function(exec){
    try {
      return !!exec();
    } catch(e){
      return true;
    }
  };
  
  /***/ }),
  /* 21 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var anObject       = __webpack_require__(2)
    , IE8_DOM_DEFINE = __webpack_require__(150)
    , toPrimitive    = __webpack_require__(81)
    , dP             = Object.defineProperty;
  
  exports.f = __webpack_require__(23) ? Object.defineProperty : function defineProperty(O, P, Attributes){
    anObject(O);
    P = toPrimitive(P, true);
    anObject(Attributes);
    if(IE8_DOM_DEFINE)try {
      return dP(O, P, Attributes);
    } catch(e){ /* empty */ }
    if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
    if('value' in Attributes)O[P] = Attributes.value;
    return O;
  };
  
  /***/ }),
  /* 22 */,
  /* 23 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // Thank's IE8 for his funny defineProperty
  module.exports = !__webpack_require__(20)(function(){
    return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
  });
  
  /***/ }),
  /* 24 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
  var has         = __webpack_require__(14)
    , toObject    = __webpack_require__(80)
    , IE_PROTO    = __webpack_require__(76)('IE_PROTO')
    , ObjectProto = Object.prototype;
  
  module.exports = Object.getPrototypeOf || function(O){
    O = toObject(O);
    if(has(O, IE_PROTO))return O[IE_PROTO];
    if(typeof O.constructor == 'function' && O instanceof O.constructor){
      return O.constructor.prototype;
    } return O instanceof Object ? ObjectProto : null;
  };
  
  /***/ }),
  /* 25 */,
  /* 26 */
  /***/ (function(module, exports) {
  
  var g;
  
  // This works in non-strict mode
  g = (function() {
  	return this;
  })();
  
  try {
  	// This works if eval is allowed (see CSP)
  	g = g || Function("return this")() || (1,eval)("this");
  } catch(e) {
  	// This works if the window reference is available
  	if(typeof window === "object")
  		g = window;
  }
  
  // g can still be undefined, but nothing to do about it...
  // We return undefined, instead of nothing here, so it's
  // easier to handle this case. if(!global) { ...}
  
  module.exports = g;
  
  
  /***/ }),
  /* 27 */,
  /* 28 */,
  /* 29 */,
  /* 30 */
  /***/ (function(module, exports) {
  
  module.exports = function(it){
    if(typeof it != 'function')throw TypeError(it + ' is not a function!');
    return it;
  };
  
  /***/ }),
  /* 31 */
  /***/ (function(module, exports) {
  
  var core = module.exports = {version: '2.4.0'};
  if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
  
  /***/ }),
  /* 32 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // optional / simple context binding
  var aFunction = __webpack_require__(30);
  module.exports = function(fn, that, length){
    aFunction(fn);
    if(that === undefined)return fn;
    switch(length){
      case 1: return function(a){
        return fn.call(that, a);
      };
      case 2: return function(a, b){
        return fn.call(that, a, b);
      };
      case 3: return function(a, b, c){
        return fn.call(that, a, b, c);
      };
    }
    return function(/* ...args */){
      return fn.apply(that, arguments);
    };
  };
  
  /***/ }),
  /* 33 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var pIE            = __webpack_require__(155)
    , createDesc     = __webpack_require__(44)
    , toIObject      = __webpack_require__(78)
    , toPrimitive    = __webpack_require__(81)
    , has            = __webpack_require__(14)
    , IE8_DOM_DEFINE = __webpack_require__(150)
    , gOPD           = Object.getOwnPropertyDescriptor;
  
  exports.f = __webpack_require__(23) ? gOPD : function getOwnPropertyDescriptor(O, P){
    O = toIObject(O);
    P = toPrimitive(P, true);
    if(IE8_DOM_DEFINE)try {
      return gOPD(O, P);
    } catch(e){ /* empty */ }
    if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);
  };
  
  /***/ }),
  /* 34 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var global    = __webpack_require__(12)
    , hide      = __webpack_require__(42)
    , has       = __webpack_require__(14)
    , SRC       = __webpack_require__(45)('src')
    , TO_STRING = 'toString'
    , $toString = Function[TO_STRING]
    , TPL       = ('' + $toString).split(TO_STRING);
  
  __webpack_require__(31).inspectSource = function(it){
    return $toString.call(it);
  };
  
  (module.exports = function(O, key, val, safe){
    var isFunction = typeof val == 'function';
    if(isFunction)has(val, 'name') || hide(val, 'name', key);
    if(O[key] === val)return;
    if(isFunction)has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
    if(O === global){
      O[key] = val;
    } else {
      if(!safe){
        delete O[key];
        hide(O, key, val);
      } else {
        if(O[key])O[key] = val;
        else hide(O, key, val);
      }
    }
  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
  })(Function.prototype, TO_STRING, function toString(){
    return typeof this == 'function' && this[SRC] || $toString.call(this);
  });
  
  /***/ }),
  /* 35 */,
  /* 36 */,
  /* 37 */,
  /* 38 */,
  /* 39 */,
  /* 40 */,
  /* 41 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var ctx         = __webpack_require__(32)
    , call        = __webpack_require__(239)
    , isArrayIter = __webpack_require__(237)
    , anObject    = __webpack_require__(2)
    , toLength    = __webpack_require__(79)
    , getIterFn   = __webpack_require__(250)
    , 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;
  
  /***/ }),
  /* 42 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var dP         = __webpack_require__(21)
    , createDesc = __webpack_require__(44);
  module.exports = __webpack_require__(23) ? function(object, key, value){
    return dP.f(object, key, createDesc(1, value));
  } : function(object, key, value){
    object[key] = value;
    return object;
  };
  
  /***/ }),
  /* 43 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var META     = __webpack_require__(45)('meta')
    , isObject = __webpack_require__(8)
    , has      = __webpack_require__(14)
    , setDesc  = __webpack_require__(21).f
    , id       = 0;
  var isExtensible = Object.isExtensible || function(){
    return true;
  };
  var FREEZE = !__webpack_require__(20)(function(){
    return isExtensible(Object.preventExtensions({}));
  });
  var setMeta = function(it){
    setDesc(it, META, {value: {
      i: 'O' + ++id, // object ID
      w: {}          // weak collections IDs
    }});
  };
  var fastKey = function(it, create){
    // return primitive with prefix
    if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
    if(!has(it, META)){
      // can't set metadata to uncaught frozen object
      if(!isExtensible(it))return 'F';
      // not necessary to add metadata
      if(!create)return 'E';
      // add missing metadata
      setMeta(it);
    // return object ID
    } return it[META].i;
  };
  var getWeak = function(it, create){
    if(!has(it, META)){
      // can't set metadata to uncaught frozen object
      if(!isExtensible(it))return true;
      // not necessary to add metadata
      if(!create)return false;
      // add missing metadata
      setMeta(it);
    // return hash weak collections IDs
    } return it[META].w;
  };
  // add metadata on freeze-family methods calling
  var onFreeze = function(it){
    if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it);
    return it;
  };
  var meta = module.exports = {
    KEY:      META,
    NEED:     false,
    fastKey:  fastKey,
    getWeak:  getWeak,
    onFreeze: onFreeze
  };
  
  /***/ }),
  /* 44 */
  /***/ (function(module, exports) {
  
  module.exports = function(bitmap, value){
    return {
      enumerable  : !(bitmap & 1),
      configurable: !(bitmap & 2),
      writable    : !(bitmap & 4),
      value       : value
    };
  };
  
  /***/ }),
  /* 45 */
  /***/ (function(module, exports) {
  
  var id = 0
    , px = Math.random();
  module.exports = function(key){
    return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
  };
  
  /***/ }),
  /* 46 */,
  /* 47 */,
  /* 48 */,
  /* 49 */,
  /* 50 */,
  /* 51 */,
  /* 52 */,
  /* 53 */,
  /* 54 */,
  /* 55 */,
  /* 56 */,
  /* 57 */,
  /* 58 */,
  /* 59 */,
  /* 60 */,
  /* 61 */,
  /* 62 */,
  /* 63 */,
  /* 64 */,
  /* 65 */,
  /* 66 */
  /***/ (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;
  };
  
  /***/ }),
  /* 67 */
  /***/ (function(module, exports) {
  
  var toString = {}.toString;
  
  module.exports = function(it){
    return toString.call(it).slice(8, -1);
  };
  
  /***/ }),
  /* 68 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var global            = __webpack_require__(12)
    , $export           = __webpack_require__(4)
    , redefine          = __webpack_require__(34)
    , redefineAll       = __webpack_require__(74)
    , meta              = __webpack_require__(43)
    , forOf             = __webpack_require__(41)
    , anInstance        = __webpack_require__(66)
    , isObject          = __webpack_require__(8)
    , fails             = __webpack_require__(20)
    , $iterDetect       = __webpack_require__(241)
    , setToStringTag    = __webpack_require__(75)
    , inheritIfRequired = __webpack_require__(235);
  
  module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){
    var Base  = global[NAME]
      , C     = Base
      , ADDER = IS_MAP ? 'set' : 'add'
      , proto = C && C.prototype
      , O     = {};
    var fixMethod = function(KEY){
      var fn = proto[KEY];
      redefine(proto, KEY,
        KEY == 'delete' ? function(a){
          return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
        } : KEY == 'has' ? function has(a){
          return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
        } : KEY == 'get' ? function get(a){
          return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);
        } : KEY == 'add' ? function add(a){ fn.call(this, a === 0 ? 0 : a); return this; }
          : function set(a, b){ fn.call(this, a === 0 ? 0 : a, b); return this; }
      );
    };
    if(typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function(){
      new C().entries().next();
    }))){
      // create collection constructor
      C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
      redefineAll(C.prototype, methods);
      meta.NEED = true;
    } else {
      var instance             = new C
        // early implementations not supports chaining
        , HASNT_CHAINING       = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance
        // V8 ~  Chromium 40- weak-collections throws on primitives, but should return false
        , THROWS_ON_PRIMITIVES = fails(function(){ instance.has(1); })
        // most early implementations doesn't supports iterables, most modern - not close it correctly
        , ACCEPT_ITERABLES     = $iterDetect(function(iter){ new C(iter); }) // eslint-disable-line no-new
        // for early implementations -0 and +0 not the same
        , BUGGY_ZERO = !IS_WEAK && fails(function(){
          // V8 ~ Chromium 42- fails only with 5+ elements
          var $instance = new C()
            , index     = 5;
          while(index--)$instance[ADDER](index, index);
          return !$instance.has(-0);
        });
      if(!ACCEPT_ITERABLES){ 
        C = wrapper(function(target, iterable){
          anInstance(target, C, NAME);
          var that = inheritIfRequired(new Base, target, C);
          if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
          return that;
        });
        C.prototype = proto;
        proto.constructor = C;
      }
      if(THROWS_ON_PRIMITIVES || BUGGY_ZERO){
        fixMethod('delete');
        fixMethod('has');
        IS_MAP && fixMethod('get');
      }
      if(BUGGY_ZERO || HASNT_CHAINING)fixMethod(ADDER);
      // weak collections should not contains .clear method
      if(IS_WEAK && proto.clear)delete proto.clear;
    }
  
    setToStringTag(C, NAME);
  
    O[NAME] = C;
    $export($export.G + $export.W + $export.F * (C != Base), O);
  
    if(!IS_WEAK)common.setStrong(C, NAME, IS_MAP);
  
    return C;
  };
  
  /***/ }),
  /* 69 */
  /***/ (function(module, exports) {
  
  // 7.2.1 RequireObjectCoercible(argument)
  module.exports = function(it){
    if(it == undefined)throw TypeError("Can't call method on  " + it);
    return it;
  };
  
  /***/ }),
  /* 70 */
  /***/ (function(module, exports) {
  
  // IE 8- don't enum bug keys
  module.exports = (
    'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
  ).split(',');
  
  /***/ }),
  /* 71 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
  var cof = __webpack_require__(67);
  module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
    return cof(it) == 'String' ? it.split('') : Object(it);
  };
  
  /***/ }),
  /* 72 */
  /***/ (function(module, exports) {
  
  module.exports = {};
  
  /***/ }),
  /* 73 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
  var anObject    = __webpack_require__(2)
    , dPs         = __webpack_require__(245)
    , enumBugKeys = __webpack_require__(70)
    , IE_PROTO    = __webpack_require__(76)('IE_PROTO')
    , Empty       = function(){ /* empty */ }
    , PROTOTYPE   = 'prototype';
  
  // Create object with fake `null` prototype: use iframe Object with cleared prototype
  var createDict = function(){
    // Thrash, waste and sodomy: IE GC bug
    var iframe = __webpack_require__(149)('iframe')
      , i      = enumBugKeys.length
      , lt     = '<'
      , gt     = '>'
      , iframeDocument;
    iframe.style.display = 'none';
    __webpack_require__(234).appendChild(iframe);
    iframe.src = 'javascript:'; // eslint-disable-line no-script-url
    // createDict = iframe.contentWindow.Object;
    // html.removeChild(iframe);
    iframeDocument = iframe.contentWindow.document;
    iframeDocument.open();
    iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
    iframeDocument.close();
    createDict = iframeDocument.F;
    while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];
    return createDict();
  };
  
  module.exports = Object.create || function create(O, Properties){
    var result;
    if(O !== null){
      Empty[PROTOTYPE] = anObject(O);
      result = new Empty;
      Empty[PROTOTYPE] = null;
      // add "__proto__" for Object.getPrototypeOf polyfill
      result[IE_PROTO] = O;
    } else result = createDict();
    return Properties === undefined ? result : dPs(result, Properties);
  };
  
  
  /***/ }),
  /* 74 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var redefine = __webpack_require__(34);
  module.exports = function(target, src, safe){
    for(var key in src)redefine(target, key, src[key], safe);
    return target;
  };
  
  /***/ }),
  /* 75 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var def = __webpack_require__(21).f
    , has = __webpack_require__(14)
    , TAG = __webpack_require__(17)('toStringTag');
  
  module.exports = function(it, tag, stat){
    if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
  };
  
  /***/ }),
  /* 76 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var shared = __webpack_require__(77)('keys')
    , uid    = __webpack_require__(45);
  module.exports = function(key){
    return shared[key] || (shared[key] = uid(key));
  };
  
  /***/ }),
  /* 77 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var global = __webpack_require__(12)
    , SHARED = '__core-js_shared__'
    , store  = global[SHARED] || (global[SHARED] = {});
  module.exports = function(key){
    return store[key] || (store[key] = {});
  };
  
  /***/ }),
  /* 78 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // to indexed object, toObject with fallback for non-array-like ES3 strings
  var IObject = __webpack_require__(71)
    , defined = __webpack_require__(69);
  module.exports = function(it){
    return IObject(defined(it));
  };
  
  /***/ }),
  /* 79 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.1.15 ToLength
  var toInteger = __webpack_require__(157)
    , min       = Math.min;
  module.exports = function(it){
    return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
  };
  
  /***/ }),
  /* 80 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.1.13 ToObject(argument)
  var defined = __webpack_require__(69);
  module.exports = function(it){
    return Object(defined(it));
  };
  
  /***/ }),
  /* 81 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.1.1 ToPrimitive(input [, PreferredType])
  var isObject = __webpack_require__(8);
  // instead of the ES6 spec version, we didn't implement @@toPrimitive case
  // and the second argument - flag - preferred type is a string
  module.exports = function(it, S){
    if(!isObject(it))return it;
    var fn, val;
    if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
    if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
    if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
    throw TypeError("Can't convert object to primitive value");
  };
  
  /***/ }),
  /* 82 */,
  /* 83 */,
  /* 84 */,
  /* 85 */,
  /* 86 */,
  /* 87 */,
  /* 88 */,
  /* 89 */,
  /* 90 */,
  /* 91 */,
  /* 92 */,
  /* 93 */,
  /* 94 */,
  /* 95 */,
  /* 96 */,
  /* 97 */,
  /* 98 */,
  /* 99 */,
  /* 100 */,
  /* 101 */,
  /* 102 */,
  /* 103 */,
  /* 104 */,
  /* 105 */,
  /* 106 */,
  /* 107 */,
  /* 108 */,
  /* 109 */,
  /* 110 */,
  /* 111 */,
  /* 112 */,
  /* 113 */,
  /* 114 */,
  /* 115 */,
  /* 116 */,
  /* 117 */,
  /* 118 */,
  /* 119 */,
  /* 120 */,
  /* 121 */,
  /* 122 */,
  /* 123 */,
  /* 124 */,
  /* 125 */,
  /* 126 */,
  /* 127 */,
  /* 128 */,
  /* 129 */,
  /* 130 */,
  /* 131 */,
  /* 132 */,
  /* 133 */,
  /* 134 */,
  /* 135 */,
  /* 136 */,
  /* 137 */,
  /* 138 */,
  /* 139 */,
  /* 140 */,
  /* 141 */,
  /* 142 */,
  /* 143 */,
  /* 144 */,
  /* 145 */,
  /* 146 */,
  /* 147 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 0 -> Array#forEach
  // 1 -> Array#map
  // 2 -> Array#filter
  // 3 -> Array#some
  // 4 -> Array#every
  // 5 -> Array#find
  // 6 -> Array#findIndex
  var ctx      = __webpack_require__(32)
    , IObject  = __webpack_require__(71)
    , toObject = __webpack_require__(80)
    , toLength = __webpack_require__(79)
    , asc      = __webpack_require__(230);
  module.exports = function(TYPE, $create){
    var IS_MAP        = TYPE == 1
      , IS_FILTER     = TYPE == 2
      , IS_SOME       = TYPE == 3
      , IS_EVERY      = TYPE == 4
      , IS_FIND_INDEX = TYPE == 6
      , NO_HOLES      = TYPE == 5 || IS_FIND_INDEX
      , create        = $create || asc;
    return function($this, callbackfn, that){
      var O      = toObject($this)
        , self   = IObject(O)
        , f      = ctx(callbackfn, that, 3)
        , length = toLength(self.length)
        , index  = 0
        , result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined
        , val, res;
      for(;length > index; index++)if(NO_HOLES || index in self){
        val = self[index];
        res = f(val, index, O);
        if(TYPE){
          if(IS_MAP)result[index] = res;            // map
          else if(res)switch(TYPE){
            case 3: return true;                    // some
            case 5: return val;                     // find
            case 6: return index;                   // findIndex
            case 2: result.push(val);               // filter
          } else if(IS_EVERY)return false;          // every
        }
      }
      return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
    };
  };
  
  /***/ }),
  /* 148 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var dP          = __webpack_require__(21).f
    , create      = __webpack_require__(73)
    , redefineAll = __webpack_require__(74)
    , ctx         = __webpack_require__(32)
    , anInstance  = __webpack_require__(66)
    , defined     = __webpack_require__(69)
    , forOf       = __webpack_require__(41)
    , $iterDefine = __webpack_require__(240)
    , step        = __webpack_require__(242)
    , setSpecies  = __webpack_require__(248)
    , DESCRIPTORS = __webpack_require__(23)
    , fastKey     = __webpack_require__(43).fastKey
    , SIZE        = DESCRIPTORS ? '_s' : 'size';
  
  var getEntry = function(that, key){
    // fast case
    var index = fastKey(key), entry;
    if(index !== 'F')return that._i[index];
    // frozen object case
    for(entry = that._f; entry; entry = entry.n){
      if(entry.k == key)return entry;
    }
  };
  
  module.exports = {
    getConstructor: function(wrapper, NAME, IS_MAP, ADDER){
      var C = wrapper(function(that, iterable){
        anInstance(that, C, NAME, '_i');
        that._i = create(null); // index
        that._f = undefined;    // first entry
        that._l = undefined;    // last entry
        that[SIZE] = 0;         // size
        if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
      });
      redefineAll(C.prototype, {
        // 23.1.3.1 Map.prototype.clear()
        // 23.2.3.2 Set.prototype.clear()
        clear: function clear(){
          for(var that = this, data = that._i, entry = that._f; entry; entry = entry.n){
            entry.r = true;
            if(entry.p)entry.p = entry.p.n = undefined;
            delete data[entry.i];
          }
          that._f = that._l = undefined;
          that[SIZE] = 0;
        },
        // 23.1.3.3 Map.prototype.delete(key)
        // 23.2.3.4 Set.prototype.delete(value)
        'delete': function(key){
          var that  = this
            , entry = getEntry(that, key);
          if(entry){
            var next = entry.n
              , prev = entry.p;
            delete that._i[entry.i];
            entry.r = true;
            if(prev)prev.n = next;
            if(next)next.p = prev;
            if(that._f == entry)that._f = next;
            if(that._l == entry)that._l = prev;
            that[SIZE]--;
          } return !!entry;
        },
        // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
        // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
        forEach: function forEach(callbackfn /*, that = undefined */){
          anInstance(this, C, 'forEach');
          var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3)
            , entry;
          while(entry = entry ? entry.n : this._f){
            f(entry.v, entry.k, this);
            // revert to the last existing entry
            while(entry && entry.r)entry = entry.p;
          }
        },
        // 23.1.3.7 Map.prototype.has(key)
        // 23.2.3.7 Set.prototype.has(value)
        has: function has(key){
          return !!getEntry(this, key);
        }
      });
      if(DESCRIPTORS)dP(C.prototype, 'size', {
        get: function(){
          return defined(this[SIZE]);
        }
      });
      return C;
    },
    def: function(that, key, value){
      var entry = getEntry(that, key)
        , prev, index;
      // change existing entry
      if(entry){
        entry.v = value;
      // create new entry
      } else {
        that._l = entry = {
          i: index = fastKey(key, true), // <- index
          k: key,                        // <- key
          v: value,                      // <- value
          p: prev = that._l,             // <- previous entry
          n: undefined,                  // <- next entry
          r: false                       // <- removed
        };
        if(!that._f)that._f = entry;
        if(prev)prev.n = entry;
        that[SIZE]++;
        // add to index
        if(index !== 'F')that._i[index] = entry;
      } return that;
    },
    getEntry: getEntry,
    setStrong: function(C, NAME, IS_MAP){
      // add .keys, .values, .entries, [@@iterator]
      // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
      $iterDefine(C, NAME, function(iterated, kind){
        this._t = iterated;  // target
        this._k = kind;      // kind
        this._l = undefined; // previous
      }, function(){
        var that  = this
          , kind  = that._k
          , entry = that._l;
        // revert to the last existing entry
        while(entry && entry.r)entry = entry.p;
        // get next entry
        if(!that._t || !(that._l = entry = entry ? entry.n : that._t._f)){
          // or finish the iteration
          that._t = undefined;
          return step(1);
        }
        // return step by kind
        if(kind == 'keys'  )return step(0, entry.k);
        if(kind == 'values')return step(0, entry.v);
        return step(0, [entry.k, entry.v]);
      }, IS_MAP ? 'entries' : 'values' , !IS_MAP, true);
  
      // add [@@species], 23.1.2.2, 23.2.2.2
      setSpecies(NAME);
    }
  };
  
  /***/ }),
  /* 149 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var isObject = __webpack_require__(8)
    , document = __webpack_require__(12).document
    // in old IE typeof document.createElement is 'object'
    , is = isObject(document) && isObject(document.createElement);
  module.exports = function(it){
    return is ? document.createElement(it) : {};
  };
  
  /***/ }),
  /* 150 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = !__webpack_require__(23) && !__webpack_require__(20)(function(){
    return Object.defineProperty(__webpack_require__(149)('div'), 'a', {get: function(){ return 7; }}).a != 7;
  });
  
  /***/ }),
  /* 151 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var create         = __webpack_require__(73)
    , descriptor     = __webpack_require__(44)
    , setToStringTag = __webpack_require__(75)
    , IteratorPrototype = {};
  
  // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
  __webpack_require__(42)(IteratorPrototype, __webpack_require__(17)('iterator'), function(){ return this; });
  
  module.exports = function(Constructor, NAME, next){
    Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});
    setToStringTag(Constructor, NAME + ' Iterator');
  };
  
  /***/ }),
  /* 152 */
  /***/ (function(module, exports) {
  
  exports.f = Object.getOwnPropertySymbols;
  
  /***/ }),
  /* 153 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var has          = __webpack_require__(14)
    , toIObject    = __webpack_require__(78)
    , arrayIndexOf = __webpack_require__(228)(false)
    , IE_PROTO     = __webpack_require__(76)('IE_PROTO');
  
  module.exports = function(object, names){
    var O      = toIObject(object)
      , i      = 0
      , result = []
      , key;
    for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
    // Don't enum bug & hidden keys
    while(names.length > i)if(has(O, key = names[i++])){
      ~arrayIndexOf(result, key) || result.push(key);
    }
    return result;
  };
  
  /***/ }),
  /* 154 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.2.14 / 15.2.3.14 Object.keys(O)
  var $keys       = __webpack_require__(153)
    , enumBugKeys = __webpack_require__(70);
  
  module.exports = Object.keys || function keys(O){
    return $keys(O, enumBugKeys);
  };
  
  /***/ }),
  /* 155 */
  /***/ (function(module, exports) {
  
  exports.f = {}.propertyIsEnumerable;
  
  /***/ }),
  /* 156 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // Works with __proto__ only. Old v8 can't work with null proto objects.
  /* eslint-disable no-proto */
  var isObject = __webpack_require__(8)
    , anObject = __webpack_require__(2);
  var check = function(O, proto){
    anObject(O);
    if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!");
  };
  module.exports = {
    set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
      function(test, buggy, set){
        try {
          set = __webpack_require__(32)(Function.call, __webpack_require__(33).f(Object.prototype, '__proto__').set, 2);
          set(test, []);
          buggy = !(test instanceof Array);
        } catch(e){ buggy = true; }
        return function setPrototypeOf(O, proto){
          check(O, proto);
          if(buggy)O.__proto__ = proto;
          else set(O, proto);
          return O;
        };
      }({}, false) : undefined),
    check: check
  };
  
  /***/ }),
  /* 157 */
  /***/ (function(module, exports) {
  
  // 7.1.4 ToInteger
  var ceil  = Math.ceil
    , floor = Math.floor;
  module.exports = function(it){
    return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
  };
  
  /***/ }),
  /* 158 */,
  /* 159 */,
  /* 160 */,
  /* 161 */,
  /* 162 */,
  /* 163 */,
  /* 164 */,
  /* 165 */,
  /* 166 */,
  /* 167 */,
  /* 168 */,
  /* 169 */,
  /* 170 */,
  /* 171 */,
  /* 172 */,
  /* 173 */,
  /* 174 */,
  /* 175 */,
  /* 176 */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_core_js_es6_reflect__ = __webpack_require__(225);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_core_js_es6_reflect___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_core_js_es6_reflect__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_core_js_es7_reflect__ = __webpack_require__(226);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_core_js_es7_reflect___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_core_js_es7_reflect__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_zone_js_dist_zone__ = __webpack_require__(380);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_zone_js_dist_zone___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_zone_js_dist_zone__);
  /**
   * This file includes polyfills needed by Angular and is loaded before the app.
   * You can add your own extra polyfills to this file.
   *
   * This file is divided into 2 sections:
   *   1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.
   *   2. Application imports. Files imported after ZoneJS that should be loaded before your main
   *      file.
   *
   * The current setup is for so-called "evergreen" browsers; the last versions of browsers that
   * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera),
   * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile.
   *
   * Learn more in https://angular.io/docs/ts/latest/guide/browser-support.html
   */
  /***************************************************************************************************
   * BROWSER POLYFILLS
   */
  /** IE9, IE10 and IE11 requires all of the following polyfills. **/
  // import 'core-js/es6/symbol';
  // import 'core-js/es6/object';
  // import 'core-js/es6/function';
  // import 'core-js/es6/parse-int';
  // import 'core-js/es6/parse-float';
  // import 'core-js/es6/number';
  // import 'core-js/es6/math';
  // import 'core-js/es6/string';
  // import 'core-js/es6/date';
  // import 'core-js/es6/array';
  // import 'core-js/es6/regexp';
  // import 'core-js/es6/map';
  // import 'core-js/es6/set';
  /** IE10 and IE11 requires the following for NgClass support on SVG elements */
  // import 'classlist.js';  // Run `npm install --save classlist.js`.
  /** IE10 and IE11 requires the following to support `@angular/animation`. */
  // import 'web-animations-js';  // Run `npm install --save web-animations-js`.
  /** Evergreen browsers require these. **/
  
  
  /** ALL Firefox browsers require the following to support `@angular/animation`. **/
  // import 'web-animations-js';  // Run `npm install --save web-animations-js`.
  /***************************************************************************************************
   * Zone JS is required by Angular itself.
   */
   // Included with Angular CLI.
  /***************************************************************************************************
   * APPLICATION IMPORTS
   */
  /**
   * Date, currency, decimal and percent pipes.
   * Needed for: All but Chrome, Firefox, Edge, IE11 and Safari 10
   */
  // import 'intl';  // Run `npm install --save intl`.
  /**
   * Need to import at least one locale-data with intl.
   */
  // import 'intl/locale-data/jsonp/en';
  //# sourceMappingURL=polyfills.js.map
  
  /***/ }),
  /* 177 */,
  /* 178 */,
  /* 179 */,
  /* 180 */,
  /* 181 */,
  /* 182 */,
  /* 183 */,
  /* 184 */,
  /* 185 */,
  /* 186 */,
  /* 187 */,
  /* 188 */,
  /* 189 */,
  /* 190 */,
  /* 191 */,
  /* 192 */,
  /* 193 */,
  /* 194 */,
  /* 195 */,
  /* 196 */,
  /* 197 */,
  /* 198 */,
  /* 199 */,
  /* 200 */,
  /* 201 */,
  /* 202 */,
  /* 203 */,
  /* 204 */,
  /* 205 */,
  /* 206 */,
  /* 207 */,
  /* 208 */,
  /* 209 */,
  /* 210 */,
  /* 211 */,
  /* 212 */,
  /* 213 */,
  /* 214 */,
  /* 215 */,
  /* 216 */,
  /* 217 */,
  /* 218 */,
  /* 219 */,
  /* 220 */,
  /* 221 */,
  /* 222 */,
  /* 223 */,
  /* 224 */,
  /* 225 */
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__(252);
  __webpack_require__(253);
  __webpack_require__(254);
  __webpack_require__(255);
  __webpack_require__(256);
  __webpack_require__(259);
  __webpack_require__(257);
  __webpack_require__(258);
  __webpack_require__(260);
  __webpack_require__(261);
  __webpack_require__(262);
  __webpack_require__(263);
  __webpack_require__(265);
  __webpack_require__(264);
  module.exports = __webpack_require__(31).Reflect;
  
  /***/ }),
  /* 226 */
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__(268);
  __webpack_require__(269);
  __webpack_require__(271);
  __webpack_require__(270);
  __webpack_require__(273);
  __webpack_require__(272);
  __webpack_require__(274);
  __webpack_require__(275);
  __webpack_require__(276);
  module.exports = __webpack_require__(31).Reflect;
  
  
  /***/ }),
  /* 227 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var forOf = __webpack_require__(41);
  
  module.exports = function(iter, ITERATOR){
    var result = [];
    forOf(iter, false, result.push, result, ITERATOR);
    return result;
  };
  
  
  /***/ }),
  /* 228 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // false -> Array#indexOf
  // true  -> Array#includes
  var toIObject = __webpack_require__(78)
    , toLength  = __webpack_require__(79)
    , toIndex   = __webpack_require__(249);
  module.exports = function(IS_INCLUDES){
    return function($this, el, fromIndex){
      var O      = toIObject($this)
        , length = toLength(O.length)
        , index  = toIndex(fromIndex, length)
        , value;
      // Array#includes uses SameValueZero equality algorithm
      if(IS_INCLUDES && el != el)while(length > index){
        value = O[index++];
        if(value != value)return true;
      // Array#toIndex ignores holes, Array#includes - not
      } else for(;length > index; index++)if(IS_INCLUDES || index in O){
        if(O[index] === el)return IS_INCLUDES || index || 0;
      } return !IS_INCLUDES && -1;
    };
  };
  
  /***/ }),
  /* 229 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var isObject = __webpack_require__(8)
    , isArray  = __webpack_require__(238)
    , SPECIES  = __webpack_require__(17)('species');
  
  module.exports = function(original){
    var C;
    if(isArray(original)){
      C = original.constructor;
      // cross-realm fallback
      if(typeof C == 'function' && (C === Array || isArray(C.prototype)))C = undefined;
      if(isObject(C)){
        C = C[SPECIES];
        if(C === null)C = undefined;
      }
    } return C === undefined ? Array : C;
  };
  
  /***/ }),
  /* 230 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 9.4.2.3 ArraySpeciesCreate(originalArray, length)
  var speciesConstructor = __webpack_require__(229);
  
  module.exports = function(original, length){
    return new (speciesConstructor(original))(length);
  };
  
  /***/ }),
  /* 231 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var aFunction  = __webpack_require__(30)
    , isObject   = __webpack_require__(8)
    , invoke     = __webpack_require__(236)
    , arraySlice = [].slice
    , factories  = {};
  
  var construct = function(F, len, args){
    if(!(len in factories)){
      for(var n = [], i = 0; i < len; i++)n[i] = 'a[' + i + ']';
      factories[len] = Function('F,a', 'return new F(' + n.join(',') + ')');
    } return factories[len](F, args);
  };
  
  module.exports = Function.bind || function bind(that /*, args... */){
    var fn       = aFunction(this)
      , partArgs = arraySlice.call(arguments, 1);
    var bound = function(/* args... */){
      var args = partArgs.concat(arraySlice.call(arguments));
      return this instanceof bound ? construct(fn, args.length, args) : invoke(fn, args, that);
    };
    if(isObject(fn.prototype))bound.prototype = fn.prototype;
    return bound;
  };
  
  /***/ }),
  /* 232 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // getting tag from 19.1.3.6 Object.prototype.toString()
  var cof = __webpack_require__(67)
    , TAG = __webpack_require__(17)('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;
  };
  
  /***/ }),
  /* 233 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var redefineAll       = __webpack_require__(74)
    , getWeak           = __webpack_require__(43).getWeak
    , anObject          = __webpack_require__(2)
    , isObject          = __webpack_require__(8)
    , anInstance        = __webpack_require__(66)
    , forOf             = __webpack_require__(41)
    , createArrayMethod = __webpack_require__(147)
    , $has              = __webpack_require__(14)
    , arrayFind         = createArrayMethod(5)
    , arrayFindIndex    = createArrayMethod(6)
    , id                = 0;
  
  // fallback for uncaught frozen keys
  var uncaughtFrozenStore = function(that){
    return that._l || (that._l = new UncaughtFrozenStore);
  };
  var UncaughtFrozenStore = function(){
    this.a = [];
  };
  var findUncaughtFrozen = function(store, key){
    return arrayFind(store.a, function(it){
      return it[0] === key;
    });
  };
  UncaughtFrozenStore.prototype = {
    get: function(key){
      var entry = findUncaughtFrozen(this, key);
      if(entry)return entry[1];
    },
    has: function(key){
      return !!findUncaughtFrozen(this, key);
    },
    set: function(key, value){
      var entry = findUncaughtFrozen(this, key);
      if(entry)entry[1] = value;
      else this.a.push([key, value]);
    },
    'delete': function(key){
      var index = arrayFindIndex(this.a, function(it){
        return it[0] === key;
      });
      if(~index)this.a.splice(index, 1);
      return !!~index;
    }
  };
  
  module.exports = {
    getConstructor: function(wrapper, NAME, IS_MAP, ADDER){
      var C = wrapper(function(that, iterable){
        anInstance(that, C, NAME, '_i');
        that._i = id++;      // collection id
        that._l = undefined; // leak store for uncaught frozen objects
        if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
      });
      redefineAll(C.prototype, {
        // 23.3.3.2 WeakMap.prototype.delete(key)
        // 23.4.3.3 WeakSet.prototype.delete(value)
        'delete': function(key){
          if(!isObject(key))return false;
          var data = getWeak(key);
          if(data === true)return uncaughtFrozenStore(this)['delete'](key);
          return data && $has(data, this._i) && delete data[this._i];
        },
        // 23.3.3.4 WeakMap.prototype.has(key)
        // 23.4.3.4 WeakSet.prototype.has(value)
        has: function has(key){
          if(!isObject(key))return false;
          var data = getWeak(key);
          if(data === true)return uncaughtFrozenStore(this).has(key);
          return data && $has(data, this._i);
        }
      });
      return C;
    },
    def: function(that, key, value){
      var data = getWeak(anObject(key), true);
      if(data === true)uncaughtFrozenStore(that).set(key, value);
      else data[that._i] = value;
      return that;
    },
    ufstore: uncaughtFrozenStore
  };
  
  /***/ }),
  /* 234 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__(12).document && document.documentElement;
  
  /***/ }),
  /* 235 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var isObject       = __webpack_require__(8)
    , setPrototypeOf = __webpack_require__(156).set;
  module.exports = function(that, target, C){
    var P, S = target.constructor;
    if(S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf){
      setPrototypeOf(that, P);
    } return that;
  };
  
  /***/ }),
  /* 236 */
  /***/ (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);
  };
  
  /***/ }),
  /* 237 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // check on default Array iterator
  var Iterators  = __webpack_require__(72)
    , ITERATOR   = __webpack_require__(17)('iterator')
    , ArrayProto = Array.prototype;
  
  module.exports = function(it){
    return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
  };
  
  /***/ }),
  /* 238 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.2.2 IsArray(argument)
  var cof = __webpack_require__(67);
  module.exports = Array.isArray || function isArray(arg){
    return cof(arg) == 'Array';
  };
  
  /***/ }),
  /* 239 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // call something on iterator step with safe closing on error
  var anObject = __webpack_require__(2);
  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;
    }
  };
  
  /***/ }),
  /* 240 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var LIBRARY        = __webpack_require__(243)
    , $export        = __webpack_require__(4)
    , redefine       = __webpack_require__(34)
    , hide           = __webpack_require__(42)
    , has            = __webpack_require__(14)
    , Iterators      = __webpack_require__(72)
    , $iterCreate    = __webpack_require__(151)
    , setToStringTag = __webpack_require__(75)
    , getPrototypeOf = __webpack_require__(24)
    , ITERATOR       = __webpack_require__(17)('iterator')
    , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
    , FF_ITERATOR    = '@@iterator'
    , KEYS           = 'keys'
    , VALUES         = 'values';
  
  var returnThis = function(){ return this; };
  
  module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
    $iterCreate(Constructor, NAME, next);
    var getMethod = function(kind){
      if(!BUGGY && kind in proto)return proto[kind];
      switch(kind){
        case KEYS: return function keys(){ return new Constructor(this, kind); };
        case VALUES: return function values(){ return new Constructor(this, kind); };
      } return function entries(){ return new Constructor(this, kind); };
    };
    var TAG        = NAME + ' Iterator'
      , DEF_VALUES = DEFAULT == VALUES
      , VALUES_BUG = false
      , proto      = Base.prototype
      , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
      , $default   = $native || getMethod(DEFAULT)
      , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined
      , $anyNative = NAME == 'Array' ? proto.entries || $native : $native
      , methods, key, IteratorPrototype;
    // Fix native
    if($anyNative){
      IteratorPrototype = getPrototypeOf($anyNative.call(new Base));
      if(IteratorPrototype !== Object.prototype){
        // Set @@toStringTag to native iterators
        setToStringTag(IteratorPrototype, TAG, true);
        // fix for some old engines
        if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
      }
    }
    // fix Array#{values, @@iterator}.name in V8 / FF
    if(DEF_VALUES && $native && $native.name !== VALUES){
      VALUES_BUG = true;
      $default = function values(){ return $native.call(this); };
    }
    // Define iterator
    if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){
      hide(proto, ITERATOR, $default);
    }
    // Plug for library
    Iterators[NAME] = $default;
    Iterators[TAG]  = returnThis;
    if(DEFAULT){
      methods = {
        values:  DEF_VALUES ? $default : getMethod(VALUES),
        keys:    IS_SET     ? $default : getMethod(KEYS),
        entries: $entries
      };
      if(FORCED)for(key in methods){
        if(!(key in proto))redefine(proto, key, methods[key]);
      } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
    }
    return methods;
  };
  
  /***/ }),
  /* 241 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var ITERATOR     = __webpack_require__(17)('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;
  };
  
  /***/ }),
  /* 242 */
  /***/ (function(module, exports) {
  
  module.exports = function(done, value){
    return {value: value, done: !!done};
  };
  
  /***/ }),
  /* 243 */
  /***/ (function(module, exports) {
  
  module.exports = false;
  
  /***/ }),
  /* 244 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  // 19.1.2.1 Object.assign(target, source, ...)
  var getKeys  = __webpack_require__(154)
    , gOPS     = __webpack_require__(152)
    , pIE      = __webpack_require__(155)
    , toObject = __webpack_require__(80)
    , IObject  = __webpack_require__(71)
    , $assign  = Object.assign;
  
  // should work with symbols and should have deterministic property order (V8 bug)
  module.exports = !$assign || __webpack_require__(20)(function(){
    var A = {}
      , B = {}
      , S = Symbol()
      , K = 'abcdefghijklmnopqrst';
    A[S] = 7;
    K.split('').forEach(function(k){ B[k] = k; });
    return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
  }) ? function assign(target, source){ // eslint-disable-line no-unused-vars
    var T     = toObject(target)
      , aLen  = arguments.length
      , index = 1
      , getSymbols = gOPS.f
      , isEnum     = pIE.f;
    while(aLen > index){
      var S      = IObject(arguments[index++])
        , keys   = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)
        , length = keys.length
        , j      = 0
        , key;
      while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];
    } return T;
  } : $assign;
  
  /***/ }),
  /* 245 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var dP       = __webpack_require__(21)
    , anObject = __webpack_require__(2)
    , getKeys  = __webpack_require__(154);
  
  module.exports = __webpack_require__(23) ? Object.defineProperties : function defineProperties(O, Properties){
    anObject(O);
    var keys   = getKeys(Properties)
      , length = keys.length
      , i = 0
      , P;
    while(length > i)dP.f(O, P = keys[i++], Properties[P]);
    return O;
  };
  
  /***/ }),
  /* 246 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
  var $keys      = __webpack_require__(153)
    , hiddenKeys = __webpack_require__(70).concat('length', 'prototype');
  
  exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){
    return $keys(O, hiddenKeys);
  };
  
  /***/ }),
  /* 247 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // all object keys, includes non-enumerable and symbols
  var gOPN     = __webpack_require__(246)
    , gOPS     = __webpack_require__(152)
    , anObject = __webpack_require__(2)
    , Reflect  = __webpack_require__(12).Reflect;
  module.exports = Reflect && Reflect.ownKeys || function ownKeys(it){
    var keys       = gOPN.f(anObject(it))
      , getSymbols = gOPS.f;
    return getSymbols ? keys.concat(getSymbols(it)) : keys;
  };
  
  /***/ }),
  /* 248 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var global      = __webpack_require__(12)
    , dP          = __webpack_require__(21)
    , DESCRIPTORS = __webpack_require__(23)
    , SPECIES     = __webpack_require__(17)('species');
  
  module.exports = function(KEY){
    var C = global[KEY];
    if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {
      configurable: true,
      get: function(){ return this; }
    });
  };
  
  /***/ }),
  /* 249 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var toInteger = __webpack_require__(157)
    , max       = Math.max
    , min       = Math.min;
  module.exports = function(index, length){
    index = toInteger(index);
    return index < 0 ? max(index + length, 0) : min(index, length);
  };
  
  /***/ }),
  /* 250 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var classof   = __webpack_require__(232)
    , ITERATOR  = __webpack_require__(17)('iterator')
    , Iterators = __webpack_require__(72);
  module.exports = __webpack_require__(31).getIteratorMethod = function(it){
    if(it != undefined)return it[ITERATOR]
      || it['@@iterator']
      || Iterators[classof(it)];
  };
  
  /***/ }),
  /* 251 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var strong = __webpack_require__(148);
  
  // 23.1 Map Objects
  module.exports = __webpack_require__(68)('Map', function(get){
    return function Map(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
  }, {
    // 23.1.3.6 Map.prototype.get(key)
    get: function get(key){
      var entry = strong.getEntry(this, key);
      return entry && entry.v;
    },
    // 23.1.3.9 Map.prototype.set(key, value)
    set: function set(key, value){
      return strong.def(this, key === 0 ? 0 : key, value);
    }
  }, strong, true);
  
  /***/ }),
  /* 252 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.1 Reflect.apply(target, thisArgument, argumentsList)
  var $export   = __webpack_require__(4)
    , aFunction = __webpack_require__(30)
    , anObject  = __webpack_require__(2)
    , rApply    = (__webpack_require__(12).Reflect || {}).apply
    , fApply    = Function.apply;
  // MS Edge argumentsList argument is optional
  $export($export.S + $export.F * !__webpack_require__(20)(function(){
    rApply(function(){});
  }), 'Reflect', {
    apply: function apply(target, thisArgument, argumentsList){
      var T = aFunction(target)
        , L = anObject(argumentsList);
      return rApply ? rApply(T, thisArgument, L) : fApply.call(T, thisArgument, L);
    }
  });
  
  /***/ }),
  /* 253 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.2 Reflect.construct(target, argumentsList [, newTarget])
  var $export    = __webpack_require__(4)
    , create     = __webpack_require__(73)
    , aFunction  = __webpack_require__(30)
    , anObject   = __webpack_require__(2)
    , isObject   = __webpack_require__(8)
    , fails      = __webpack_require__(20)
    , bind       = __webpack_require__(231)
    , rConstruct = (__webpack_require__(12).Reflect || {}).construct;
  
  // MS Edge supports only 2 arguments and argumentsList argument is optional
  // FF Nightly sets third argument as `new.target`, but does not create `this` from it
  var NEW_TARGET_BUG = fails(function(){
    function F(){}
    return !(rConstruct(function(){}, [], F) instanceof F);
  });
  var ARGS_BUG = !fails(function(){
    rConstruct(function(){});
  });
  
  $export($export.S + $export.F * (NEW_TARGET_BUG || ARGS_BUG), 'Reflect', {
    construct: function construct(Target, args /*, newTarget*/){
      aFunction(Target);
      anObject(args);
      var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]);
      if(ARGS_BUG && !NEW_TARGET_BUG)return rConstruct(Target, args, newTarget);
      if(Target == newTarget){
        // w/o altered newTarget, optimization for 0-4 arguments
        switch(args.length){
          case 0: return new Target;
          case 1: return new Target(args[0]);
          case 2: return new Target(args[0], args[1]);
          case 3: return new Target(args[0], args[1], args[2]);
          case 4: return new Target(args[0], args[1], args[2], args[3]);
        }
        // w/o altered newTarget, lot of arguments case
        var $args = [null];
        $args.push.apply($args, args);
        return new (bind.apply(Target, $args));
      }
      // with altered newTarget, not support built-in constructors
      var proto    = newTarget.prototype
        , instance = create(isObject(proto) ? proto : Object.prototype)
        , result   = Function.apply.call(Target, instance, args);
      return isObject(result) ? result : instance;
    }
  });
  
  /***/ }),
  /* 254 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.3 Reflect.defineProperty(target, propertyKey, attributes)
  var dP          = __webpack_require__(21)
    , $export     = __webpack_require__(4)
    , anObject    = __webpack_require__(2)
    , toPrimitive = __webpack_require__(81);
  
  // MS Edge has broken Reflect.defineProperty - throwing instead of returning false
  $export($export.S + $export.F * __webpack_require__(20)(function(){
    Reflect.defineProperty(dP.f({}, 1, {value: 1}), 1, {value: 2});
  }), 'Reflect', {
    defineProperty: function defineProperty(target, propertyKey, attributes){
      anObject(target);
      propertyKey = toPrimitive(propertyKey, true);
      anObject(attributes);
      try {
        dP.f(target, propertyKey, attributes);
        return true;
      } catch(e){
        return false;
      }
    }
  });
  
  /***/ }),
  /* 255 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.4 Reflect.deleteProperty(target, propertyKey)
  var $export  = __webpack_require__(4)
    , gOPD     = __webpack_require__(33).f
    , anObject = __webpack_require__(2);
  
  $export($export.S, 'Reflect', {
    deleteProperty: function deleteProperty(target, propertyKey){
      var desc = gOPD(anObject(target), propertyKey);
      return desc && !desc.configurable ? false : delete target[propertyKey];
    }
  });
  
  /***/ }),
  /* 256 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  // 26.1.5 Reflect.enumerate(target)
  var $export  = __webpack_require__(4)
    , anObject = __webpack_require__(2);
  var Enumerate = function(iterated){
    this._t = anObject(iterated); // target
    this._i = 0;                  // next index
    var keys = this._k = []       // keys
      , key;
    for(key in iterated)keys.push(key);
  };
  __webpack_require__(151)(Enumerate, 'Object', function(){
    var that = this
      , keys = that._k
      , key;
    do {
      if(that._i >= keys.length)return {value: undefined, done: true};
    } while(!((key = keys[that._i++]) in that._t));
    return {value: key, done: false};
  });
  
  $export($export.S, 'Reflect', {
    enumerate: function enumerate(target){
      return new Enumerate(target);
    }
  });
  
  /***/ }),
  /* 257 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.7 Reflect.getOwnPropertyDescriptor(target, propertyKey)
  var gOPD     = __webpack_require__(33)
    , $export  = __webpack_require__(4)
    , anObject = __webpack_require__(2);
  
  $export($export.S, 'Reflect', {
    getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey){
      return gOPD.f(anObject(target), propertyKey);
    }
  });
  
  /***/ }),
  /* 258 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.8 Reflect.getPrototypeOf(target)
  var $export  = __webpack_require__(4)
    , getProto = __webpack_require__(24)
    , anObject = __webpack_require__(2);
  
  $export($export.S, 'Reflect', {
    getPrototypeOf: function getPrototypeOf(target){
      return getProto(anObject(target));
    }
  });
  
  /***/ }),
  /* 259 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.6 Reflect.get(target, propertyKey [, receiver])
  var gOPD           = __webpack_require__(33)
    , getPrototypeOf = __webpack_require__(24)
    , has            = __webpack_require__(14)
    , $export        = __webpack_require__(4)
    , isObject       = __webpack_require__(8)
    , anObject       = __webpack_require__(2);
  
  function get(target, propertyKey/*, receiver*/){
    var receiver = arguments.length < 3 ? target : arguments[2]
      , desc, proto;
    if(anObject(target) === receiver)return target[propertyKey];
    if(desc = gOPD.f(target, propertyKey))return has(desc, 'value')
      ? desc.value
      : desc.get !== undefined
        ? desc.get.call(receiver)
        : undefined;
    if(isObject(proto = getPrototypeOf(target)))return get(proto, propertyKey, receiver);
  }
  
  $export($export.S, 'Reflect', {get: get});
  
  /***/ }),
  /* 260 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.9 Reflect.has(target, propertyKey)
  var $export = __webpack_require__(4);
  
  $export($export.S, 'Reflect', {
    has: function has(target, propertyKey){
      return propertyKey in target;
    }
  });
  
  /***/ }),
  /* 261 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.10 Reflect.isExtensible(target)
  var $export       = __webpack_require__(4)
    , anObject      = __webpack_require__(2)
    , $isExtensible = Object.isExtensible;
  
  $export($export.S, 'Reflect', {
    isExtensible: function isExtensible(target){
      anObject(target);
      return $isExtensible ? $isExtensible(target) : true;
    }
  });
  
  /***/ }),
  /* 262 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.11 Reflect.ownKeys(target)
  var $export = __webpack_require__(4);
  
  $export($export.S, 'Reflect', {ownKeys: __webpack_require__(247)});
  
  /***/ }),
  /* 263 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.12 Reflect.preventExtensions(target)
  var $export            = __webpack_require__(4)
    , anObject           = __webpack_require__(2)
    , $preventExtensions = Object.preventExtensions;
  
  $export($export.S, 'Reflect', {
    preventExtensions: function preventExtensions(target){
      anObject(target);
      try {
        if($preventExtensions)$preventExtensions(target);
        return true;
      } catch(e){
        return false;
      }
    }
  });
  
  /***/ }),
  /* 264 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.14 Reflect.setPrototypeOf(target, proto)
  var $export  = __webpack_require__(4)
    , setProto = __webpack_require__(156);
  
  if(setProto)$export($export.S, 'Reflect', {
    setPrototypeOf: function setPrototypeOf(target, proto){
      setProto.check(target, proto);
      try {
        setProto.set(target, proto);
        return true;
      } catch(e){
        return false;
      }
    }
  });
  
  /***/ }),
  /* 265 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 26.1.13 Reflect.set(target, propertyKey, V [, receiver])
  var dP             = __webpack_require__(21)
    , gOPD           = __webpack_require__(33)
    , getPrototypeOf = __webpack_require__(24)
    , has            = __webpack_require__(14)
    , $export        = __webpack_require__(4)
    , createDesc     = __webpack_require__(44)
    , anObject       = __webpack_require__(2)
    , isObject       = __webpack_require__(8);
  
  function set(target, propertyKey, V/*, receiver*/){
    var receiver = arguments.length < 4 ? target : arguments[3]
      , ownDesc  = gOPD.f(anObject(target), propertyKey)
      , existingDescriptor, proto;
    if(!ownDesc){
      if(isObject(proto = getPrototypeOf(target))){
        return set(proto, propertyKey, V, receiver);
      }
      ownDesc = createDesc(0);
    }
    if(has(ownDesc, 'value')){
      if(ownDesc.writable === false || !isObject(receiver))return false;
      existingDescriptor = gOPD.f(receiver, propertyKey) || createDesc(0);
      existingDescriptor.value = V;
      dP.f(receiver, propertyKey, existingDescriptor);
      return true;
    }
    return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true);
  }
  
  $export($export.S, 'Reflect', {set: set});
  
  /***/ }),
  /* 266 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var strong = __webpack_require__(148);
  
  // 23.2 Set Objects
  module.exports = __webpack_require__(68)('Set', function(get){
    return function Set(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
  }, {
    // 23.2.3.1 Set.prototype.add(value)
    add: function add(value){
      return strong.def(this, value = value === 0 ? 0 : value, value);
    }
  }, strong);
  
  /***/ }),
  /* 267 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var each         = __webpack_require__(147)(0)
    , redefine     = __webpack_require__(34)
    , meta         = __webpack_require__(43)
    , assign       = __webpack_require__(244)
    , weak         = __webpack_require__(233)
    , isObject     = __webpack_require__(8)
    , getWeak      = meta.getWeak
    , isExtensible = Object.isExtensible
    , uncaughtFrozenStore = weak.ufstore
    , tmp          = {}
    , InternalMap;
  
  var wrapper = function(get){
    return function WeakMap(){
      return get(this, arguments.length > 0 ? arguments[0] : undefined);
    };
  };
  
  var methods = {
    // 23.3.3.3 WeakMap.prototype.get(key)
    get: function get(key){
      if(isObject(key)){
        var data = getWeak(key);
        if(data === true)return uncaughtFrozenStore(this).get(key);
        return data ? data[this._i] : undefined;
      }
    },
    // 23.3.3.5 WeakMap.prototype.set(key, value)
    set: function set(key, value){
      return weak.def(this, key, value);
    }
  };
  
  // 23.3 WeakMap Objects
  var $WeakMap = module.exports = __webpack_require__(68)('WeakMap', wrapper, methods, weak, true, true);
  
  // IE11 WeakMap frozen keys fix
  if(new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7){
    InternalMap = weak.getConstructor(wrapper);
    assign(InternalMap.prototype, methods);
    meta.NEED = true;
    each(['delete', 'has', 'get', 'set'], function(key){
      var proto  = $WeakMap.prototype
        , method = proto[key];
      redefine(proto, key, function(a, b){
        // store frozen objects on internal weakmap shim
        if(isObject(a) && !isExtensible(a)){
          if(!this._f)this._f = new InternalMap;
          var result = this._f[key](a, b);
          return key == 'set' ? this : result;
        // store all the rest on native weakmap
        } return method.call(this, a, b);
      });
    });
  }
  
  /***/ }),
  /* 268 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var metadata                  = __webpack_require__(16)
    , anObject                  = __webpack_require__(2)
    , toMetaKey                 = metadata.key
    , ordinaryDefineOwnMetadata = metadata.set;
  
  metadata.exp({defineMetadata: function defineMetadata(metadataKey, metadataValue, target, targetKey){
    ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), toMetaKey(targetKey));
  }});
  
  /***/ }),
  /* 269 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var metadata               = __webpack_require__(16)
    , anObject               = __webpack_require__(2)
    , toMetaKey              = metadata.key
    , getOrCreateMetadataMap = metadata.map
    , store                  = metadata.store;
  
  metadata.exp({deleteMetadata: function deleteMetadata(metadataKey, target /*, targetKey */){
    var targetKey   = arguments.length < 3 ? undefined : toMetaKey(arguments[2])
      , metadataMap = getOrCreateMetadataMap(anObject(target), targetKey, false);
    if(metadataMap === undefined || !metadataMap['delete'](metadataKey))return false;
    if(metadataMap.size)return true;
    var targetMetadata = store.get(target);
    targetMetadata['delete'](targetKey);
    return !!targetMetadata.size || store['delete'](target);
  }});
  
  /***/ }),
  /* 270 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var Set                     = __webpack_require__(266)
    , from                    = __webpack_require__(227)
    , metadata                = __webpack_require__(16)
    , anObject                = __webpack_require__(2)
    , getPrototypeOf          = __webpack_require__(24)
    , ordinaryOwnMetadataKeys = metadata.keys
    , toMetaKey               = metadata.key;
  
  var ordinaryMetadataKeys = function(O, P){
    var oKeys  = ordinaryOwnMetadataKeys(O, P)
      , parent = getPrototypeOf(O);
    if(parent === null)return oKeys;
    var pKeys  = ordinaryMetadataKeys(parent, P);
    return pKeys.length ? oKeys.length ? from(new Set(oKeys.concat(pKeys))) : pKeys : oKeys;
  };
  
  metadata.exp({getMetadataKeys: function getMetadataKeys(target /*, targetKey */){
    return ordinaryMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1]));
  }});
  
  /***/ }),
  /* 271 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var metadata               = __webpack_require__(16)
    , anObject               = __webpack_require__(2)
    , getPrototypeOf         = __webpack_require__(24)
    , ordinaryHasOwnMetadata = metadata.has
    , ordinaryGetOwnMetadata = metadata.get
    , toMetaKey              = metadata.key;
  
  var ordinaryGetMetadata = function(MetadataKey, O, P){
    var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);
    if(hasOwn)return ordinaryGetOwnMetadata(MetadataKey, O, P);
    var parent = getPrototypeOf(O);
    return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined;
  };
  
  metadata.exp({getMetadata: function getMetadata(metadataKey, target /*, targetKey */){
    return ordinaryGetMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
  }});
  
  /***/ }),
  /* 272 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var metadata                = __webpack_require__(16)
    , anObject                = __webpack_require__(2)
    , ordinaryOwnMetadataKeys = metadata.keys
    , toMetaKey               = metadata.key;
  
  metadata.exp({getOwnMetadataKeys: function getOwnMetadataKeys(target /*, targetKey */){
    return ordinaryOwnMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1]));
  }});
  
  /***/ }),
  /* 273 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var metadata               = __webpack_require__(16)
    , anObject               = __webpack_require__(2)
    , ordinaryGetOwnMetadata = metadata.get
    , toMetaKey              = metadata.key;
  
  metadata.exp({getOwnMetadata: function getOwnMetadata(metadataKey, target /*, targetKey */){
    return ordinaryGetOwnMetadata(metadataKey, anObject(target)
      , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
  }});
  
  /***/ }),
  /* 274 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var metadata               = __webpack_require__(16)
    , anObject               = __webpack_require__(2)
    , getPrototypeOf         = __webpack_require__(24)
    , ordinaryHasOwnMetadata = metadata.has
    , toMetaKey              = metadata.key;
  
  var ordinaryHasMetadata = function(MetadataKey, O, P){
    var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);
    if(hasOwn)return true;
    var parent = getPrototypeOf(O);
    return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false;
  };
  
  metadata.exp({hasMetadata: function hasMetadata(metadataKey, target /*, targetKey */){
    return ordinaryHasMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
  }});
  
  /***/ }),
  /* 275 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var metadata               = __webpack_require__(16)
    , anObject               = __webpack_require__(2)
    , ordinaryHasOwnMetadata = metadata.has
    , toMetaKey              = metadata.key;
  
  metadata.exp({hasOwnMetadata: function hasOwnMetadata(metadataKey, target /*, targetKey */){
    return ordinaryHasOwnMetadata(metadataKey, anObject(target)
      , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
  }});
  
  /***/ }),
  /* 276 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var metadata                  = __webpack_require__(16)
    , anObject                  = __webpack_require__(2)
    , aFunction                 = __webpack_require__(30)
    , toMetaKey                 = metadata.key
    , ordinaryDefineOwnMetadata = metadata.set;
  
  metadata.exp({metadata: function metadata(metadataKey, metadataValue){
    return function decorator(target, targetKey){
      ordinaryDefineOwnMetadata(
        metadataKey, metadataValue,
        (targetKey !== undefined ? anObject : aFunction)(target),
        toMetaKey(targetKey)
      );
    };
  }});
  
  /***/ }),
  /* 277 */,
  /* 278 */,
  /* 279 */,
  /* 280 */,
  /* 281 */,
  /* 282 */,
  /* 283 */,
  /* 284 */,
  /* 285 */,
  /* 286 */,
  /* 287 */,
  /* 288 */,
  /* 289 */,
  /* 290 */,
  /* 291 */,
  /* 292 */,
  /* 293 */,
  /* 294 */,
  /* 295 */,
  /* 296 */,
  /* 297 */,
  /* 298 */,
  /* 299 */,
  /* 300 */,
  /* 301 */,
  /* 302 */,
  /* 303 */,
  /* 304 */,
  /* 305 */,
  /* 306 */,
  /* 307 */,
  /* 308 */,
  /* 309 */,
  /* 310 */,
  /* 311 */,
  /* 312 */,
  /* 313 */,
  /* 314 */,
  /* 315 */,
  /* 316 */,
  /* 317 */,
  /* 318 */,
  /* 319 */,
  /* 320 */,
  /* 321 */,
  /* 322 */,
  /* 323 */,
  /* 324 */,
  /* 325 */,
  /* 326 */,
  /* 327 */,
  /* 328 */,
  /* 329 */,
  /* 330 */,
  /* 331 */,
  /* 332 */,
  /* 333 */,
  /* 334 */,
  /* 335 */,
  /* 336 */,
  /* 337 */,
  /* 338 */,
  /* 339 */,
  /* 340 */,
  /* 341 */,
  /* 342 */,
  /* 343 */,
  /* 344 */,
  /* 345 */,
  /* 346 */,
  /* 347 */,
  /* 348 */,
  /* 349 */,
  /* 350 */,
  /* 351 */,
  /* 352 */,
  /* 353 */,
  /* 354 */,
  /* 355 */,
  /* 356 */,
  /* 357 */,
  /* 358 */,
  /* 359 */,
  /* 360 */,
  /* 361 */,
  /* 362 */,
  /* 363 */,
  /* 364 */,
  /* 365 */,
  /* 366 */,
  /* 367 */,
  /* 368 */,
  /* 369 */,
  /* 370 */,
  /* 371 */,
  /* 372 */,
  /* 373 */,
  /* 374 */,
  /* 375 */,
  /* 376 */,
  /* 377 */,
  /* 378 */,
  /* 379 */,
  /* 380 */
  /***/ (function(module, exports, __webpack_require__) {
  
  /* WEBPACK VAR INJECTION */(function(global) {/**
  * @license
  * Copyright Google Inc. All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
  (function (global, factory) {
  	 true ? factory() :
  	typeof define === 'function' && define.amd ? define(factory) :
  	(factory());
  }(this, (function () { 'use strict';
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  var Zone$1 = (function (global) {
      var performance = global['performance'];
      function mark(name) {
          performance && performance['mark'] && performance['mark'](name);
      }
      function performanceMeasure(name, label) {
          performance && performance['measure'] && performance['measure'](name, label);
      }
      mark('Zone');
      if (global['Zone']) {
          throw new Error('Zone already loaded.');
      }
      var Zone = (function () {
          function Zone(parent, zoneSpec) {
              this._properties = null;
              this._parent = parent;
              this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '<root>';
              this._properties = zoneSpec && zoneSpec.properties || {};
              this._zoneDelegate =
                  new ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);
          }
          Zone.assertZonePatched = function () {
              if (global['Promise'] !== patches['ZoneAwarePromise']) {
                  throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' +
                      'has been overwritten.\n' +
                      'Most likely cause is that a Promise polyfill has been loaded ' +
                      'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' +
                      'If you must load one, do so before loading zone.js.)');
              }
          };
          Object.defineProperty(Zone, "root", {
              get: function () {
                  var zone = Zone.current;
                  while (zone.parent) {
                      zone = zone.parent;
                  }
                  return zone;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(Zone, "current", {
              get: function () {
                  return _currentZoneFrame.zone;
              },
              enumerable: true,
              configurable: true
          });
          
          Object.defineProperty(Zone, "currentTask", {
              get: function () {
                  return _currentTask;
              },
              enumerable: true,
              configurable: true
          });
          
          Zone.__load_patch = function (name, fn) {
              if (patches.hasOwnProperty(name)) {
                  throw Error('Already loaded patch: ' + name);
              }
              else if (!global['__Zone_disable_' + name]) {
                  var perfName = 'Zone:' + name;
                  mark(perfName);
                  patches[name] = fn(global, Zone, _api);
                  performanceMeasure(perfName, perfName);
              }
          };
          Object.defineProperty(Zone.prototype, "parent", {
              get: function () {
                  return this._parent;
              },
              enumerable: true,
              configurable: true
          });
          
          Object.defineProperty(Zone.prototype, "name", {
              get: function () {
                  return this._name;
              },
              enumerable: true,
              configurable: true
          });
          
          Zone.prototype.get = function (key) {
              var zone = this.getZoneWith(key);
              if (zone)
                  return zone._properties[key];
          };
          Zone.prototype.getZoneWith = function (key) {
              var current = this;
              while (current) {
                  if (current._properties.hasOwnProperty(key)) {
                      return current;
                  }
                  current = current._parent;
              }
              return null;
          };
          Zone.prototype.fork = function (zoneSpec) {
              if (!zoneSpec)
                  throw new Error('ZoneSpec required!');
              return this._zoneDelegate.fork(this, zoneSpec);
          };
          Zone.prototype.wrap = function (callback, source) {
              if (typeof callback !== 'function') {
                  throw new Error('Expecting function got: ' + callback);
              }
              var _callback = this._zoneDelegate.intercept(this, callback, source);
              var zone = this;
              return function () {
                  return zone.runGuarded(_callback, this, arguments, source);
              };
          };
          Zone.prototype.run = function (callback, applyThis, applyArgs, source) {
              if (applyThis === void 0) { applyThis = undefined; }
              if (applyArgs === void 0) { applyArgs = null; }
              if (source === void 0) { source = null; }
              _currentZoneFrame = { parent: _currentZoneFrame, zone: this };
              try {
                  return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
              }
              finally {
                  _currentZoneFrame = _currentZoneFrame.parent;
              }
          };
          Zone.prototype.runGuarded = function (callback, applyThis, applyArgs, source) {
              if (applyThis === void 0) { applyThis = null; }
              if (applyArgs === void 0) { applyArgs = null; }
              if (source === void 0) { source = null; }
              _currentZoneFrame = { parent: _currentZoneFrame, zone: this };
              try {
                  try {
                      return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
                  }
                  catch (error) {
                      if (this._zoneDelegate.handleError(this, error)) {
                          throw error;
                      }
                  }
              }
              finally {
                  _currentZoneFrame = _currentZoneFrame.parent;
              }
          };
          Zone.prototype.runTask = function (task, applyThis, applyArgs) {
              if (task.zone != this) {
                  throw new Error('A task can only be run in the zone of creation! (Creation: ' +
                      (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');
              }
              // https://github.com/angular/zone.js/issues/778, sometimes eventTask
              // will run in notScheduled(canceled) state, we should not try to
              // run such kind of task but just return
              // we have to define an variable here, if not
              // typescript compiler will complain below
              var isNotScheduled = task.state === notScheduled;
              if (isNotScheduled && task.type === eventTask) {
                  return;
              }
              var reEntryGuard = task.state != running;
              reEntryGuard && task._transitionTo(running, scheduled);
              task.runCount++;
              var previousTask = _currentTask;
              _currentTask = task;
              _currentZoneFrame = { parent: _currentZoneFrame, zone: this };
              try {
                  if (task.type == macroTask && task.data && !task.data.isPeriodic) {
                      task.cancelFn = null;
                  }
                  try {
                      return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);
                  }
                  catch (error) {
                      if (this._zoneDelegate.handleError(this, error)) {
                          throw error;
                      }
                  }
              }
              finally {
                  // if the task's state is notScheduled or unknown, then it has already been cancelled
                  // we should not reset the state to scheduled
                  if (task.state !== notScheduled && task.state !== unknown) {
                      if (task.type == eventTask || (task.data && task.data.isPeriodic)) {
                          reEntryGuard && task._transitionTo(scheduled, running);
                      }
                      else {
                          task.runCount = 0;
                          this._updateTaskCount(task, -1);
                          reEntryGuard &&
                              task._transitionTo(notScheduled, running, notScheduled);
                      }
                  }
                  _currentZoneFrame = _currentZoneFrame.parent;
                  _currentTask = previousTask;
              }
          };
          Zone.prototype.scheduleTask = function (task) {
              if (task.zone && task.zone !== this) {
                  // check if the task was rescheduled, the newZone
                  // should not be the children of the original zone
                  var newZone = this;
                  while (newZone) {
                      if (newZone === task.zone) {
                          throw Error("can not reschedule task to " + this
                              .name + " which is descendants of the original zone " + task.zone.name);
                      }
                      newZone = newZone.parent;
                  }
              }
              task._transitionTo(scheduling, notScheduled);
              var zoneDelegates = [];
              task._zoneDelegates = zoneDelegates;
              task._zone = this;
              try {
                  task = this._zoneDelegate.scheduleTask(this, task);
              }
              catch (err) {
                  // should set task's state to unknown when scheduleTask throw error
                  // because the err may from reschedule, so the fromState maybe notScheduled
                  task._transitionTo(unknown, scheduling, notScheduled);
                  // TODO: @JiaLiPassion, should we check the result from handleError?
                  this._zoneDelegate.handleError(this, err);
                  throw err;
              }
              if (task._zoneDelegates === zoneDelegates) {
                  // we have to check because internally the delegate can reschedule the task.
                  this._updateTaskCount(task, 1);
              }
              if (task.state == scheduling) {
                  task._transitionTo(scheduled, scheduling);
              }
              return task;
          };
          Zone.prototype.scheduleMicroTask = function (source, callback, data, customSchedule) {
              return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, null));
          };
          Zone.prototype.scheduleMacroTask = function (source, callback, data, customSchedule, customCancel) {
              return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel));
          };
          Zone.prototype.scheduleEventTask = function (source, callback, data, customSchedule, customCancel) {
              return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel));
          };
          Zone.prototype.cancelTask = function (task) {
              if (task.zone != this)
                  throw new Error('A task can only be cancelled in the zone of creation! (Creation: ' +
                      (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');
              task._transitionTo(canceling, scheduled, running);
              try {
                  this._zoneDelegate.cancelTask(this, task);
              }
              catch (err) {
                  // if error occurs when cancelTask, transit the state to unknown
                  task._transitionTo(unknown, canceling);
                  this._zoneDelegate.handleError(this, err);
                  throw err;
              }
              this._updateTaskCount(task, -1);
              task._transitionTo(notScheduled, canceling);
              task.runCount = 0;
              return task;
          };
          Zone.prototype._updateTaskCount = function (task, count) {
              var zoneDelegates = task._zoneDelegates;
              if (count == -1) {
                  task._zoneDelegates = null;
              }
              for (var i = 0; i < zoneDelegates.length; i++) {
                  zoneDelegates[i]._updateTaskCount(task.type, count);
              }
          };
          return Zone;
      }());
      Zone.__symbol__ = __symbol__;
      var DELEGATE_ZS = {
          name: '',
          onHasTask: function (delegate, _, target, hasTaskState) {
              return delegate.hasTask(target, hasTaskState);
          },
          onScheduleTask: function (delegate, _, target, task) {
              return delegate.scheduleTask(target, task);
          },
          onInvokeTask: function (delegate, _, target, task, applyThis, applyArgs) { return delegate.invokeTask(target, task, applyThis, applyArgs); },
          onCancelTask: function (delegate, _, target, task) {
              return delegate.cancelTask(target, task);
          }
      };
      var ZoneDelegate = (function () {
          function ZoneDelegate(zone, parentDelegate, zoneSpec) {
              this._taskCounts = { 'microTask': 0, 'macroTask': 0, 'eventTask': 0 };
              this.zone = zone;
              this._parentDelegate = parentDelegate;
              this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);
              this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);
              this._forkCurrZone = zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate.zone);
              this._interceptZS =
                  zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);
              this._interceptDlgt =
                  zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);
              this._interceptCurrZone =
                  zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate.zone);
              this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);
              this._invokeDlgt =
                  zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);
              this._invokeCurrZone = zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate.zone);
              this._handleErrorZS =
                  zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);
              this._handleErrorDlgt =
                  zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);
              this._handleErrorCurrZone =
                  zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate.zone);
              this._scheduleTaskZS =
                  zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);
              this._scheduleTaskDlgt =
                  zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);
              this._scheduleTaskCurrZone =
                  zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate.zone);
              this._invokeTaskZS =
                  zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);
              this._invokeTaskDlgt =
                  zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);
              this._invokeTaskCurrZone =
                  zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate.zone);
              this._cancelTaskZS =
                  zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);
              this._cancelTaskDlgt =
                  zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);
              this._cancelTaskCurrZone =
                  zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate.zone);
              this._hasTaskZS = null;
              this._hasTaskDlgt = null;
              this._hasTaskDlgtOwner = null;
              this._hasTaskCurrZone = null;
              var zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask;
              var parentHasTask = parentDelegate && parentDelegate._hasTaskZS;
              if (zoneSpecHasTask || parentHasTask) {
                  // If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such
                  // a case all task related interceptors must go through this ZD. We can't short circuit it.
                  this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS;
                  this._hasTaskDlgt = parentDelegate;
                  this._hasTaskDlgtOwner = this;
                  this._hasTaskCurrZone = zone;
                  if (!zoneSpec.onScheduleTask) {
                      this._scheduleTaskZS = DELEGATE_ZS;
                      this._scheduleTaskDlgt = parentDelegate;
                      this._scheduleTaskCurrZone = this.zone;
                  }
                  if (!zoneSpec.onInvokeTask) {
                      this._invokeTaskZS = DELEGATE_ZS;
                      this._invokeTaskDlgt = parentDelegate;
                      this._invokeTaskCurrZone = this.zone;
                  }
                  if (!zoneSpec.onCancelTask) {
                      this._cancelTaskZS = DELEGATE_ZS;
                      this._cancelTaskDlgt = parentDelegate;
                      this._cancelTaskCurrZone = this.zone;
                  }
              }
          }
          ZoneDelegate.prototype.fork = function (targetZone, zoneSpec) {
              return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :
                  new Zone(targetZone, zoneSpec);
          };
          ZoneDelegate.prototype.intercept = function (targetZone, callback, source) {
              return this._interceptZS ?
                  this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) :
                  callback;
          };
          ZoneDelegate.prototype.invoke = function (targetZone, callback, applyThis, applyArgs, source) {
              return this._invokeZS ?
                  this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) :
                  callback.apply(applyThis, applyArgs);
          };
          ZoneDelegate.prototype.handleError = function (targetZone, error) {
              return this._handleErrorZS ?
                  this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) :
                  true;
          };
          ZoneDelegate.prototype.scheduleTask = function (targetZone, task) {
              var returnTask = task;
              if (this._scheduleTaskZS) {
                  if (this._hasTaskZS) {
                      returnTask._zoneDelegates.push(this._hasTaskDlgtOwner);
                  }
                  returnTask = this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);
                  if (!returnTask)
                      returnTask = task;
              }
              else {
                  if (task.scheduleFn) {
                      task.scheduleFn(task);
                  }
                  else if (task.type == microTask) {
                      scheduleMicroTask(task);
                  }
                  else {
                      throw new Error('Task is missing scheduleFn.');
                  }
              }
              return returnTask;
          };
          ZoneDelegate.prototype.invokeTask = function (targetZone, task, applyThis, applyArgs) {
              return this._invokeTaskZS ?
                  this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) :
                  task.callback.apply(applyThis, applyArgs);
          };
          ZoneDelegate.prototype.cancelTask = function (targetZone, task) {
              var value;
              if (this._cancelTaskZS) {
                  value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);
              }
              else {
                  if (!task.cancelFn) {
                      throw Error('Task is not cancelable');
                  }
                  value = task.cancelFn(task);
              }
              return value;
          };
          ZoneDelegate.prototype.hasTask = function (targetZone, isEmpty) {
              // hasTask should not throw error so other ZoneDelegate
              // can still trigger hasTask callback
              try {
                  return this._hasTaskZS &&
                      this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);
              }
              catch (err) {
                  this.handleError(targetZone, err);
              }
          };
          ZoneDelegate.prototype._updateTaskCount = function (type, count) {
              var counts = this._taskCounts;
              var prev = counts[type];
              var next = counts[type] = prev + count;
              if (next < 0) {
                  throw new Error('More tasks executed then were scheduled.');
              }
              if (prev == 0 || next == 0) {
                  var isEmpty = {
                      microTask: counts.microTask > 0,
                      macroTask: counts.macroTask > 0,
                      eventTask: counts.eventTask > 0,
                      change: type
                  };
                  this.hasTask(this.zone, isEmpty);
              }
          };
          return ZoneDelegate;
      }());
      var ZoneTask = (function () {
          function ZoneTask(type, source, callback, options, scheduleFn, cancelFn) {
              this._zone = null;
              this.runCount = 0;
              this._zoneDelegates = null;
              this._state = 'notScheduled';
              this.type = type;
              this.source = source;
              this.data = options;
              this.scheduleFn = scheduleFn;
              this.cancelFn = cancelFn;
              this.callback = callback;
              var self = this;
              this.invoke = function () {
                  _numberOfNestedTaskFrames++;
                  try {
                      self.runCount++;
                      return self.zone.runTask(self, this, arguments);
                  }
                  finally {
                      if (_numberOfNestedTaskFrames == 1) {
                          drainMicroTaskQueue();
                      }
                      _numberOfNestedTaskFrames--;
                  }
              };
          }
          Object.defineProperty(ZoneTask.prototype, "zone", {
              get: function () {
                  return this._zone;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(ZoneTask.prototype, "state", {
              get: function () {
                  return this._state;
              },
              enumerable: true,
              configurable: true
          });
          ZoneTask.prototype.cancelScheduleRequest = function () {
              this._transitionTo(notScheduled, scheduling);
          };
          ZoneTask.prototype._transitionTo = function (toState, fromState1, fromState2) {
              if (this._state === fromState1 || this._state === fromState2) {
                  this._state = toState;
                  if (toState == notScheduled) {
                      this._zoneDelegates = null;
                  }
              }
              else {
                  throw new Error(this.type + " '" + this.source + "': can not transition to '" + toState + "', expecting state '" + fromState1 + "'" + (fromState2 ?
                      ' or \'' + fromState2 + '\'' :
                      '') + ", was '" + this._state + "'.");
              }
          };
          ZoneTask.prototype.toString = function () {
              if (this.data && typeof this.data.handleId !== 'undefined') {
                  return this.data.handleId;
              }
              else {
                  return Object.prototype.toString.call(this);
              }
          };
          // add toJSON method to prevent cyclic error when
          // call JSON.stringify(zoneTask)
          ZoneTask.prototype.toJSON = function () {
              return {
                  type: this.type,
                  state: this.state,
                  source: this.source,
                  zone: this.zone.name,
                  invoke: this.invoke,
                  scheduleFn: this.scheduleFn,
                  cancelFn: this.cancelFn,
                  runCount: this.runCount,
                  callback: this.callback
              };
          };
          return ZoneTask;
      }());
      //////////////////////////////////////////////////////
      //////////////////////////////////////////////////////
      ///  MICROTASK QUEUE
      //////////////////////////////////////////////////////
      //////////////////////////////////////////////////////
      var symbolSetTimeout = __symbol__('setTimeout');
      var symbolPromise = __symbol__('Promise');
      var symbolThen = __symbol__('then');
      var _microTaskQueue = [];
      var _isDrainingMicrotaskQueue = false;
      function scheduleMicroTask(task) {
          // if we are not running in any task, and there has not been anything scheduled
          // we must bootstrap the initial task creation by manually scheduling the drain
          if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {
              // We are not running in Task, so we need to kickstart the microtask queue.
              if (global[symbolPromise]) {
                  global[symbolPromise].resolve(0)[symbolThen](drainMicroTaskQueue);
              }
              else {
                  global[symbolSetTimeout](drainMicroTaskQueue, 0);
              }
          }
          task && _microTaskQueue.push(task);
      }
      function drainMicroTaskQueue() {
          if (!_isDrainingMicrotaskQueue) {
              _isDrainingMicrotaskQueue = true;
              while (_microTaskQueue.length) {
                  var queue = _microTaskQueue;
                  _microTaskQueue = [];
                  for (var i = 0; i < queue.length; i++) {
                      var task = queue[i];
                      try {
                          task.zone.runTask(task, null, null);
                      }
                      catch (error) {
                          _api.onUnhandledError(error);
                      }
                  }
              }
              var showError = !Zone[__symbol__('ignoreConsoleErrorUncaughtError')];
              _api.microtaskDrainDone();
              _isDrainingMicrotaskQueue = false;
          }
      }
      //////////////////////////////////////////////////////
      //////////////////////////////////////////////////////
      ///  BOOTSTRAP
      //////////////////////////////////////////////////////
      //////////////////////////////////////////////////////
      var NO_ZONE = { name: 'NO ZONE' };
      var notScheduled = 'notScheduled', scheduling = 'scheduling', scheduled = 'scheduled', running = 'running', canceling = 'canceling', unknown = 'unknown';
      var microTask = 'microTask', macroTask = 'macroTask', eventTask = 'eventTask';
      var patches = {};
      var _api = {
          symbol: __symbol__,
          currentZoneFrame: function () { return _currentZoneFrame; },
          onUnhandledError: noop,
          microtaskDrainDone: noop,
          scheduleMicroTask: scheduleMicroTask,
          showUncaughtError: function () { return !Zone[__symbol__('ignoreConsoleErrorUncaughtError')]; },
          patchEventTargetMethods: function () { return false; },
          patchOnProperties: noop
      };
      var _currentZoneFrame = { parent: null, zone: new Zone(null, null) };
      var _currentTask = null;
      var _numberOfNestedTaskFrames = 0;
      function noop() { }
      function __symbol__(name) {
          return '__zone_symbol__' + name;
      }
      performanceMeasure('Zone', 'Zone');
      return global['Zone'] = Zone;
  })(typeof window !== 'undefined' && window || typeof self !== 'undefined' && self || global);
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  Zone.__load_patch('ZoneAwarePromise', function (global, Zone, api) {
      var __symbol__ = api.symbol;
      var _uncaughtPromiseErrors = [];
      var symbolPromise = __symbol__('Promise');
      var symbolThen = __symbol__('then');
      api.onUnhandledError = function (e) {
          if (api.showUncaughtError()) {
              var rejection = e && e.rejection;
              if (rejection) {
                  console.error('Unhandled Promise rejection:', rejection instanceof Error ? rejection.message : rejection, '; Zone:', e.zone.name, '; Task:', e.task && e.task.source, '; Value:', rejection, rejection instanceof Error ? rejection.stack : undefined);
              }
              console.error(e);
          }
      };
      api.microtaskDrainDone = function () {
          while (_uncaughtPromiseErrors.length) {
              var _loop_1 = function () {
                  var uncaughtPromiseError = _uncaughtPromiseErrors.shift();
                  try {
                      uncaughtPromiseError.zone.runGuarded(function () {
                          throw uncaughtPromiseError;
                      });
                  }
                  catch (error) {
                      handleUnhandledRejection(error);
                  }
              };
              while (_uncaughtPromiseErrors.length) {
                  _loop_1();
              }
          }
      };
      function handleUnhandledRejection(e) {
          api.onUnhandledError(e);
          try {
              var handler = Zone[__symbol__('unhandledPromiseRejectionHandler')];
              if (handler && typeof handler === 'function') {
                  handler.apply(this, [e]);
              }
          }
          catch (err) {
          }
      }
      function isThenable(value) {
          return value && value.then;
      }
      function forwardResolution(value) {
          return value;
      }
      function forwardRejection(rejection) {
          return ZoneAwarePromise.reject(rejection);
      }
      var symbolState = __symbol__('state');
      var symbolValue = __symbol__('value');
      var source = 'Promise.then';
      var UNRESOLVED = null;
      var RESOLVED = true;
      var REJECTED = false;
      var REJECTED_NO_CATCH = 0;
      function makeResolver(promise, state) {
          return function (v) {
              try {
                  resolvePromise(promise, state, v);
              }
              catch (err) {
                  resolvePromise(promise, false, err);
              }
              // Do not return value or you will break the Promise spec.
          };
      }
      var once = function () {
          var wasCalled = false;
          return function wrapper(wrappedFunction) {
              return function () {
                  if (wasCalled) {
                      return;
                  }
                  wasCalled = true;
                  wrappedFunction.apply(null, arguments);
              };
          };
      };
      // Promise Resolution
      function resolvePromise(promise, state, value) {
          var onceWrapper = once();
          if (promise === value) {
              throw new TypeError('Promise resolved with itself');
          }
          if (promise[symbolState] === UNRESOLVED) {
              // should only get value.then once based on promise spec.
              var then = null;
              try {
                  if (typeof value === 'object' || typeof value === 'function') {
                      then = value && value.then;
                  }
              }
              catch (err) {
                  onceWrapper(function () {
                      resolvePromise(promise, false, err);
                  })();
                  return promise;
              }
              // if (value instanceof ZoneAwarePromise) {
              if (state !== REJECTED && value instanceof ZoneAwarePromise &&
                  value.hasOwnProperty(symbolState) && value.hasOwnProperty(symbolValue) &&
                  value[symbolState] !== UNRESOLVED) {
                  clearRejectedNoCatch(value);
                  resolvePromise(promise, value[symbolState], value[symbolValue]);
              }
              else if (state !== REJECTED && typeof then === 'function') {
                  try {
                      then.apply(value, [
                          onceWrapper(makeResolver(promise, state)), onceWrapper(makeResolver(promise, false))
                      ]);
                  }
                  catch (err) {
                      onceWrapper(function () {
                          resolvePromise(promise, false, err);
                      })();
                  }
              }
              else {
                  promise[symbolState] = state;
                  var queue = promise[symbolValue];
                  promise[symbolValue] = value;
                  // record task information in value when error occurs, so we can
                  // do some additional work such as render longStackTrace
                  if (state === REJECTED && value instanceof Error) {
                      value[__symbol__('currentTask')] = Zone.currentTask;
                  }
                  for (var i = 0; i < queue.length;) {
                      scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);
                  }
                  if (queue.length == 0 && state == REJECTED) {
                      promise[symbolState] = REJECTED_NO_CATCH;
                      try {
                          throw new Error('Uncaught (in promise): ' + value +
                              (value && value.stack ? '\n' + value.stack : ''));
                      }
                      catch (err) {
                          var error_1 = err;
                          error_1.rejection = value;
                          error_1.promise = promise;
                          error_1.zone = Zone.current;
                          error_1.task = Zone.currentTask;
                          _uncaughtPromiseErrors.push(error_1);
                          api.scheduleMicroTask(); // to make sure that it is running
                      }
                  }
              }
          }
          // Resolving an already resolved promise is a noop.
          return promise;
      }
      function clearRejectedNoCatch(promise) {
          if (promise[symbolState] === REJECTED_NO_CATCH) {
              // if the promise is rejected no catch status
              // and queue.length > 0, means there is a error handler
              // here to handle the rejected promise, we should trigger
              // windows.rejectionhandled eventHandler or nodejs rejectionHandled
              // eventHandler
              try {
                  var handler = Zone[__symbol__('rejectionHandledHandler')];
                  if (handler && typeof handler === 'function') {
                      handler.apply(this, [{ rejection: promise[symbolValue], promise: promise }]);
                  }
              }
              catch (err) {
              }
              promise[symbolState] = REJECTED;
              for (var i = 0; i < _uncaughtPromiseErrors.length; i++) {
                  if (promise === _uncaughtPromiseErrors[i].promise) {
                      _uncaughtPromiseErrors.splice(i, 1);
                  }
              }
          }
      }
      function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {
          clearRejectedNoCatch(promise);
          var delegate = promise[symbolState] ?
              (typeof onFulfilled === 'function') ? onFulfilled : forwardResolution :
              (typeof onRejected === 'function') ? onRejected : forwardRejection;
          zone.scheduleMicroTask(source, function () {
              try {
                  resolvePromise(chainPromise, true, zone.run(delegate, undefined, [promise[symbolValue]]));
              }
              catch (error) {
                  resolvePromise(chainPromise, false, error);
              }
          });
      }
      var ZoneAwarePromise = (function () {
          function ZoneAwarePromise(executor) {
              var promise = this;
              if (!(promise instanceof ZoneAwarePromise)) {
                  throw new Error('Must be an instanceof Promise.');
              }
              promise[symbolState] = UNRESOLVED;
              promise[symbolValue] = []; // queue;
              try {
                  executor && executor(makeResolver(promise, RESOLVED), makeResolver(promise, REJECTED));
              }
              catch (error) {
                  resolvePromise(promise, false, error);
              }
          }
          ZoneAwarePromise.toString = function () {
              return 'function ZoneAwarePromise() { [native code] }';
          };
          ZoneAwarePromise.resolve = function (value) {
              return resolvePromise(new this(null), RESOLVED, value);
          };
          ZoneAwarePromise.reject = function (error) {
              return resolvePromise(new this(null), REJECTED, error);
          };
          ZoneAwarePromise.race = function (values) {
              var resolve;
              var reject;
              var promise = new this(function (res, rej) {
                  _a = [res, rej], resolve = _a[0], reject = _a[1];
                  var _a;
              });
              function onResolve(value) {
                  promise && (promise = null || resolve(value));
              }
              function onReject(error) {
                  promise && (promise = null || reject(error));
              }
              for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
                  var value = values_1[_i];
                  if (!isThenable(value)) {
                      value = this.resolve(value);
                  }
                  value.then(onResolve, onReject);
              }
              return promise;
          };
          ZoneAwarePromise.all = function (values) {
              var resolve;
              var reject;
              var promise = new this(function (res, rej) {
                  resolve = res;
                  reject = rej;
              });
              var count = 0;
              var resolvedValues = [];
              for (var _i = 0, values_2 = values; _i < values_2.length; _i++) {
                  var value = values_2[_i];
                  if (!isThenable(value)) {
                      value = this.resolve(value);
                  }
                  value.then((function (index) { return function (value) {
                      resolvedValues[index] = value;
                      count--;
                      if (!count) {
                          resolve(resolvedValues);
                      }
                  }; })(count), reject);
                  count++;
              }
              if (!count)
                  resolve(resolvedValues);
              return promise;
          };
          ZoneAwarePromise.prototype.then = function (onFulfilled, onRejected) {
              var chainPromise = new this.constructor(null);
              var zone = Zone.current;
              if (this[symbolState] == UNRESOLVED) {
                  this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);
              }
              else {
                  scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);
              }
              return chainPromise;
          };
          ZoneAwarePromise.prototype.catch = function (onRejected) {
              return this.then(null, onRejected);
          };
          return ZoneAwarePromise;
      }());
      // Protect against aggressive optimizers dropping seemingly unused properties.
      // E.g. Closure Compiler in advanced mode.
      ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve;
      ZoneAwarePromise['reject'] = ZoneAwarePromise.reject;
      ZoneAwarePromise['race'] = ZoneAwarePromise.race;
      ZoneAwarePromise['all'] = ZoneAwarePromise.all;
      var NativePromise = global[symbolPromise] = global['Promise'];
      global['Promise'] = ZoneAwarePromise;
      var symbolThenPatched = __symbol__('thenPatched');
      function patchThen(Ctor) {
          var proto = Ctor.prototype;
          var originalThen = proto.then;
          // Keep a reference to the original method.
          proto[symbolThen] = originalThen;
          Ctor.prototype.then = function (onResolve, onReject) {
              var _this = this;
              var wrapped = new ZoneAwarePromise(function (resolve, reject) {
                  originalThen.call(_this, resolve, reject);
              });
              return wrapped.then(onResolve, onReject);
          };
          Ctor[symbolThenPatched] = true;
      }
      function zoneify(fn) {
          return function () {
              var resultPromise = fn.apply(this, arguments);
              if (resultPromise instanceof ZoneAwarePromise) {
                  return resultPromise;
              }
              var ctor = resultPromise.constructor;
              if (!ctor[symbolThenPatched]) {
                  patchThen(ctor);
              }
              return resultPromise;
          };
      }
      if (NativePromise) {
          patchThen(NativePromise);
          var fetch_1 = global['fetch'];
          if (typeof fetch_1 == 'function') {
              global['fetch'] = zoneify(fetch_1);
          }
      }
      // This is not part of public API, but it is useful for tests, so we expose it.
      Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors;
      return ZoneAwarePromise;
  });
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /**
   * Suppress closure compiler errors about unknown 'Zone' variable
   * @fileoverview
   * @suppress {undefinedVars,globalThis}
   */
  var zoneSymbol = function (n) { return "__zone_symbol__" + n; };
  var _global = typeof window === 'object' && window || typeof self === 'object' && self || global;
  function bindArguments(args, source) {
      for (var i = args.length - 1; i >= 0; i--) {
          if (typeof args[i] === 'function') {
              args[i] = Zone.current.wrap(args[i], source + '_' + i);
          }
      }
      return args;
  }
  function patchPrototype(prototype, fnNames) {
      var source = prototype.constructor['name'];
      var _loop_1 = function (i) {
          var name_1 = fnNames[i];
          var delegate = prototype[name_1];
          if (delegate) {
              prototype[name_1] = (function (delegate) {
                  var patched = function () {
                      return delegate.apply(this, bindArguments(arguments, source + '.' + name_1));
                  };
                  attachOriginToPatched(patched, delegate);
                  return patched;
              })(delegate);
          }
      };
      for (var i = 0; i < fnNames.length; i++) {
          _loop_1(i);
      }
  }
  var isWebWorker = (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope);
  // Make sure to access `process` through `_global` so that WebPack does not accidently browserify
  // this code.
  var isNode = (!('nw' in _global) && typeof _global.process !== 'undefined' &&
      {}.toString.call(_global.process) === '[object process]');
  var isBrowser = !isNode && !isWebWorker && !!(typeof window !== 'undefined' && window['HTMLElement']);
  // we are in electron of nw, so we are both browser and nodejs
  // Make sure to access `process` through `_global` so that WebPack does not accidently browserify
  // this code.
  var isMix = typeof _global.process !== 'undefined' &&
      {}.toString.call(_global.process) === '[object process]' && !isWebWorker &&
      !!(typeof window !== 'undefined' && window['HTMLElement']);
  function patchProperty(obj, prop, prototype) {
      var desc = Object.getOwnPropertyDescriptor(obj, prop);
      if (!desc && prototype) {
          // when patch window object, use prototype to check prop exist or not
          var prototypeDesc = Object.getOwnPropertyDescriptor(prototype, prop);
          if (prototypeDesc) {
              desc = { enumerable: true, configurable: true };
          }
      }
      // if the descriptor not exists or is not configurable
      // just return
      if (!desc || !desc.configurable) {
          return;
      }
      // A property descriptor cannot have getter/setter and be writable
      // deleting the writable and value properties avoids this error:
      //
      // TypeError: property descriptors must not specify a value or be writable when a
      // getter or setter has been specified
      delete desc.writable;
      delete desc.value;
      var originalDescGet = desc.get;
      // substr(2) cuz 'onclick' -> 'click', etc
      var eventName = prop.substr(2);
      var _prop = zoneSymbol('_' + prop);
      desc.set = function (newValue) {
          // in some of windows's onproperty callback, this is undefined
          // so we need to check it
          var target = this;
          if (!target && obj === _global) {
              target = _global;
          }
          if (!target) {
              return;
          }
          var previousValue = target[_prop];
          if (previousValue) {
              target.removeEventListener(eventName, previousValue);
          }
          if (typeof newValue === 'function') {
              var wrapFn = function (event) {
                  var result = newValue.apply(this, arguments);
                  if (result != undefined && !result) {
                      event.preventDefault();
                  }
                  return result;
              };
              target[_prop] = wrapFn;
              target.addEventListener(eventName, wrapFn, false);
          }
          else {
              target[_prop] = null;
          }
      };
      // The getter would return undefined for unassigned properties but the default value of an
      // unassigned property is null
      desc.get = function () {
          // in some of windows's onproperty callback, this is undefined
          // so we need to check it
          var target = this;
          if (!target && obj === _global) {
              target = _global;
          }
          if (!target) {
              return null;
          }
          if (target.hasOwnProperty(_prop)) {
              return target[_prop];
          }
          else if (originalDescGet) {
              // result will be null when use inline event attribute,
              // such as <button onclick="func();">OK</button>
              // because the onclick function is internal raw uncompiled handler
              // the onclick will be evaluated when first time event was triggered or
              // the property is accessed, https://github.com/angular/zone.js/issues/525
              // so we should use original native get to retrieve the handler
              var value = originalDescGet && originalDescGet.apply(this);
              if (value) {
                  desc.set.apply(this, [value]);
                  if (typeof target['removeAttribute'] === 'function') {
                      target.removeAttribute(prop);
                  }
                  return value;
              }
          }
          return null;
      };
      Object.defineProperty(obj, prop, desc);
  }
  function patchOnProperties(obj, properties, prototype) {
      if (properties) {
          for (var i = 0; i < properties.length; i++) {
              patchProperty(obj, 'on' + properties[i], prototype);
          }
      }
      else {
          var onProperties = [];
          for (var prop in obj) {
              if (prop.substr(0, 2) == 'on') {
                  onProperties.push(prop);
              }
          }
          for (var j = 0; j < onProperties.length; j++) {
              patchProperty(obj, onProperties[j], prototype);
          }
      }
  }
  var EVENT_TASKS = zoneSymbol('eventTasks');
  // For EventTarget
  var ADD_EVENT_LISTENER = 'addEventListener';
  var REMOVE_EVENT_LISTENER = 'removeEventListener';
  // compare the EventListenerOptionsOrCapture
  // 1. if the options is usCapture: boolean, compare the useCpature values directly
  // 2. if the options is EventListerOptions, only compare the capture
  function compareEventListenerOptions(left, right) {
      var leftCapture = (typeof left === 'boolean') ?
          left :
          ((typeof left === 'object') ? (left && left.capture) : false);
      var rightCapture = (typeof right === 'boolean') ?
          right :
          ((typeof right === 'object') ? (right && right.capture) : false);
      return !!leftCapture === !!rightCapture;
  }
  function findExistingRegisteredTask(target, handler, name, options, remove) {
      var eventTasks = target[EVENT_TASKS];
      if (eventTasks) {
          for (var i = 0; i < eventTasks.length; i++) {
              var eventTask = eventTasks[i];
              var data = eventTask.data;
              var listener = data.handler;
              if ((data.handler === handler || listener.listener === handler) &&
                  compareEventListenerOptions(data.options, options) && data.eventName === name) {
                  if (remove) {
                      eventTasks.splice(i, 1);
                  }
                  return eventTask;
              }
          }
      }
      return null;
  }
  function attachRegisteredEvent(target, eventTask, isPrepend) {
      var eventTasks = target[EVENT_TASKS];
      if (!eventTasks) {
          eventTasks = target[EVENT_TASKS] = [];
      }
      if (isPrepend) {
          eventTasks.unshift(eventTask);
      }
      else {
          eventTasks.push(eventTask);
      }
  }
  var defaultListenerMetaCreator = function (self, args) {
      return {
          options: args[2],
          eventName: args[0],
          handler: args[1],
          target: self || _global,
          name: args[0],
          crossContext: false,
          invokeAddFunc: function (addFnSymbol, delegate) {
              // check if the data is cross site context, if it is, fallback to
              // remove the delegate directly and try catch error
              if (!this.crossContext) {
                  if (delegate && delegate.invoke) {
                      return this.target[addFnSymbol](this.eventName, delegate.invoke, this.options);
                  }
                  else {
                      return this.target[addFnSymbol](this.eventName, delegate, this.options);
                  }
              }
              else {
                  // add a if/else branch here for performance concern, for most times
                  // cross site context is false, so we don't need to try/catch
                  try {
                      return this.target[addFnSymbol](this.eventName, delegate, this.options);
                  }
                  catch (err) {
                      // do nothing here is fine, because objects in a cross-site context are unusable
                  }
              }
          },
          invokeRemoveFunc: function (removeFnSymbol, delegate) {
              // check if the data is cross site context, if it is, fallback to
              // remove the delegate directly and try catch error
              if (!this.crossContext) {
                  if (delegate && delegate.invoke) {
                      return this.target[removeFnSymbol](this.eventName, delegate.invoke, this.options);
                  }
                  else {
                      return this.target[removeFnSymbol](this.eventName, delegate, this.options);
                  }
              }
              else {
                  // add a if/else branch here for performance concern, for most times
                  // cross site context is false, so we don't need to try/catch
                  try {
                      return this.target[removeFnSymbol](this.eventName, delegate, this.options);
                  }
                  catch (err) {
                      // do nothing here is fine, because objects in a cross-site context are unusable
                  }
              }
          }
      };
  };
  function makeZoneAwareAddListener(addFnName, removeFnName, useCapturingParam, allowDuplicates, isPrepend, metaCreator) {
      if (useCapturingParam === void 0) { useCapturingParam = true; }
      if (allowDuplicates === void 0) { allowDuplicates = false; }
      if (isPrepend === void 0) { isPrepend = false; }
      if (metaCreator === void 0) { metaCreator = defaultListenerMetaCreator; }
      var addFnSymbol = zoneSymbol(addFnName);
      var removeFnSymbol = zoneSymbol(removeFnName);
      var defaultUseCapturing = useCapturingParam ? false : undefined;
      function scheduleEventListener(eventTask) {
          var meta = eventTask.data;
          attachRegisteredEvent(meta.target, eventTask, isPrepend);
          return meta.invokeAddFunc(addFnSymbol, eventTask);
      }
      function cancelEventListener(eventTask) {
          var meta = eventTask.data;
          findExistingRegisteredTask(meta.target, eventTask.invoke, meta.eventName, meta.options, true);
          return meta.invokeRemoveFunc(removeFnSymbol, eventTask);
      }
      return function zoneAwareAddListener(self, args) {
          var data = metaCreator(self, args);
          data.options = data.options || defaultUseCapturing;
          // - Inside a Web Worker, `this` is undefined, the context is `global`
          // - When `addEventListener` is called on the global context in strict mode, `this` is undefined
          // see https://github.com/angular/zone.js/issues/190
          var delegate = null;
          if (typeof data.handler == 'function') {
              delegate = data.handler;
          }
          else if (data.handler && data.handler.handleEvent) {
              delegate = function (event) { return data.handler.handleEvent(event); };
          }
          var validZoneHandler = false;
          try {
              // In cross site contexts (such as WebDriver frameworks like Selenium),
              // accessing the handler object here will cause an exception to be thrown which
              // will fail tests prematurely.
              validZoneHandler = data.handler && data.handler.toString() === '[object FunctionWrapper]';
          }
          catch (error) {
              // we can still try to add the data.handler even we are in cross site context
              data.crossContext = true;
              return data.invokeAddFunc(addFnSymbol, data.handler);
          }
          // Ignore special listeners of IE11 & Edge dev tools, see
          // https://github.com/angular/zone.js/issues/150
          if (!delegate || validZoneHandler) {
              return data.invokeAddFunc(addFnSymbol, data.handler);
          }
          if (!allowDuplicates) {
              var eventTask = findExistingRegisteredTask(data.target, data.handler, data.eventName, data.options, false);
              if (eventTask) {
                  // we already registered, so this will have noop.
                  return data.invokeAddFunc(addFnSymbol, eventTask);
              }
          }
          var zone = Zone.current;
          var source = data.target.constructor['name'] + '.' + addFnName + ':' + data.eventName;
          zone.scheduleEventTask(source, delegate, data, scheduleEventListener, cancelEventListener);
      };
  }
  function makeZoneAwareRemoveListener(fnName, useCapturingParam, metaCreator) {
      if (useCapturingParam === void 0) { useCapturingParam = true; }
      if (metaCreator === void 0) { metaCreator = defaultListenerMetaCreator; }
      var symbol = zoneSymbol(fnName);
      var defaultUseCapturing = useCapturingParam ? false : undefined;
      return function zoneAwareRemoveListener(self, args) {
          var data = metaCreator(self, args);
          data.options = data.options || defaultUseCapturing;
          // - Inside a Web Worker, `this` is undefined, the context is `global`
          // - When `addEventListener` is called on the global context in strict mode, `this` is undefined
          // see https://github.com/angular/zone.js/issues/190
          var delegate = null;
          if (typeof data.handler == 'function') {
              delegate = data.handler;
          }
          else if (data.handler && data.handler.handleEvent) {
              delegate = function (event) { return data.handler.handleEvent(event); };
          }
          var validZoneHandler = false;
          try {
              // In cross site contexts (such as WebDriver frameworks like Selenium),
              // accessing the handler object here will cause an exception to be thrown which
              // will fail tests prematurely.
              validZoneHandler = data.handler && data.handler.toString() === '[object FunctionWrapper]';
          }
          catch (error) {
              data.crossContext = true;
              return data.invokeRemoveFunc(symbol, data.handler);
          }
          // Ignore special listeners of IE11 & Edge dev tools, see
          // https://github.com/angular/zone.js/issues/150
          if (!delegate || validZoneHandler) {
              return data.invokeRemoveFunc(symbol, data.handler);
          }
          var eventTask = findExistingRegisteredTask(data.target, data.handler, data.eventName, data.options, true);
          if (eventTask) {
              eventTask.zone.cancelTask(eventTask);
          }
          else {
              data.invokeRemoveFunc(symbol, data.handler);
          }
      };
  }
  
  
  function patchEventTargetMethods(obj, addFnName, removeFnName, metaCreator) {
      if (addFnName === void 0) { addFnName = ADD_EVENT_LISTENER; }
      if (removeFnName === void 0) { removeFnName = REMOVE_EVENT_LISTENER; }
      if (metaCreator === void 0) { metaCreator = defaultListenerMetaCreator; }
      if (obj && obj[addFnName]) {
          patchMethod(obj, addFnName, function () { return makeZoneAwareAddListener(addFnName, removeFnName, true, false, false, metaCreator); });
          patchMethod(obj, removeFnName, function () { return makeZoneAwareRemoveListener(removeFnName, true, metaCreator); });
          return true;
      }
      else {
          return false;
      }
  }
  var originalInstanceKey = zoneSymbol('originalInstance');
  // wrap some native API on `window`
  function patchClass(className) {
      var OriginalClass = _global[className];
      if (!OriginalClass)
          return;
      // keep original class in global
      _global[zoneSymbol(className)] = OriginalClass;
      _global[className] = function () {
          var a = bindArguments(arguments, className);
          switch (a.length) {
              case 0:
                  this[originalInstanceKey] = new OriginalClass();
                  break;
              case 1:
                  this[originalInstanceKey] = new OriginalClass(a[0]);
                  break;
              case 2:
                  this[originalInstanceKey] = new OriginalClass(a[0], a[1]);
                  break;
              case 3:
                  this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]);
                  break;
              case 4:
                  this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]);
                  break;
              default:
                  throw new Error('Arg list too long.');
          }
      };
      // attach original delegate to patched function
      attachOriginToPatched(_global[className], OriginalClass);
      var instance = new OriginalClass(function () { });
      var prop;
      for (prop in instance) {
          // https://bugs.webkit.org/show_bug.cgi?id=44721
          if (className === 'XMLHttpRequest' && prop === 'responseBlob')
              continue;
          (function (prop) {
              if (typeof instance[prop] === 'function') {
                  _global[className].prototype[prop] = function () {
                      return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);
                  };
              }
              else {
                  Object.defineProperty(_global[className].prototype, prop, {
                      set: function (fn) {
                          if (typeof fn === 'function') {
                              this[originalInstanceKey][prop] = Zone.current.wrap(fn, className + '.' + prop);
                              // keep callback in wrapped function so we can
                              // use it in Function.prototype.toString to return
                              // the native one.
                              attachOriginToPatched(this[originalInstanceKey][prop], fn);
                          }
                          else {
                              this[originalInstanceKey][prop] = fn;
                          }
                      },
                      get: function () {
                          return this[originalInstanceKey][prop];
                      }
                  });
              }
          }(prop));
      }
      for (prop in OriginalClass) {
          if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {
              _global[className][prop] = OriginalClass[prop];
          }
      }
  }
  function patchMethod(target, name, patchFn) {
      var proto = target;
      while (proto && !proto.hasOwnProperty(name)) {
          proto = Object.getPrototypeOf(proto);
      }
      if (!proto && target[name]) {
          // somehow we did not find it, but we can see it. This happens on IE for Window properties.
          proto = target;
      }
      var delegateName = zoneSymbol(name);
      var delegate;
      if (proto && !(delegate = proto[delegateName])) {
          delegate = proto[delegateName] = proto[name];
          var patchDelegate_1 = patchFn(delegate, delegateName, name);
          proto[name] = function () {
              return patchDelegate_1(this, arguments);
          };
          attachOriginToPatched(proto[name], delegate);
      }
      return delegate;
  }
  // TODO: @JiaLiPassion, support cancel task later if necessary
  
  
  function findEventTask(target, evtName) {
      var eventTasks = target[zoneSymbol('eventTasks')];
      var result = [];
      if (eventTasks) {
          for (var i = 0; i < eventTasks.length; i++) {
              var eventTask = eventTasks[i];
              var data = eventTask.data;
              var eventName = data && data.eventName;
              if (eventName === evtName) {
                  result.push(eventTask);
              }
          }
      }
      return result;
  }
  function attachOriginToPatched(patched, original) {
      patched[zoneSymbol('OriginalDelegate')] = original;
  }
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  // override Function.prototype.toString to make zone.js patched function
  // look like native function
  Zone.__load_patch('toString', function (global, Zone, api) {
      // patch Func.prototype.toString to let them look like native
      var originalFunctionToString = Function.prototype.toString;
      Function.prototype.toString = function () {
          if (typeof this === 'function') {
              if (this[zoneSymbol('OriginalDelegate')]) {
                  return originalFunctionToString.apply(this[zoneSymbol('OriginalDelegate')], arguments);
              }
              if (this === Promise) {
                  var nativePromise = global[zoneSymbol('Promise')];
                  if (nativePromise) {
                      return originalFunctionToString.apply(nativePromise, arguments);
                  }
              }
              if (this === Error) {
                  var nativeError = global[zoneSymbol('Error')];
                  if (nativeError) {
                      return originalFunctionToString.apply(nativeError, arguments);
                  }
              }
          }
          return originalFunctionToString.apply(this, arguments);
      };
      // patch Object.prototype.toString to let them look like native
      var originalObjectToString = Object.prototype.toString;
      Object.prototype.toString = function () {
          if (this instanceof Promise) {
              return '[object Promise]';
          }
          return originalObjectToString.apply(this, arguments);
      };
  });
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  function patchTimer(window, setName, cancelName, nameSuffix) {
      var setNative = null;
      var clearNative = null;
      setName += nameSuffix;
      cancelName += nameSuffix;
      var tasksByHandleId = {};
      function scheduleTask(task) {
          var data = task.data;
          function timer() {
              try {
                  task.invoke.apply(this, arguments);
              }
              finally {
                  if (typeof data.handleId === 'number') {
                      // Node returns complex objects as handleIds
                      delete tasksByHandleId[data.handleId];
                  }
              }
          }
          data.args[0] = timer;
          data.handleId = setNative.apply(window, data.args);
          if (typeof data.handleId === 'number') {
              // Node returns complex objects as handleIds -> no need to keep them around. Additionally,
              // this throws an
              // exception in older node versions and has no effect there, because of the stringified key.
              tasksByHandleId[data.handleId] = task;
          }
          return task;
      }
      function clearTask(task) {
          if (typeof task.data.handleId === 'number') {
              // Node returns complex objects as handleIds
              delete tasksByHandleId[task.data.handleId];
          }
          return clearNative(task.data.handleId);
      }
      setNative =
          patchMethod(window, setName, function (delegate) { return function (self, args) {
              if (typeof args[0] === 'function') {
                  var zone = Zone.current;
                  var options = {
                      handleId: null,
                      isPeriodic: nameSuffix === 'Interval',
                      delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 : null,
                      args: args
                  };
                  var task = zone.scheduleMacroTask(setName, args[0], options, scheduleTask, clearTask);
                  if (!task) {
                      return task;
                  }
                  // Node.js must additionally support the ref and unref functions.
                  var handle = task.data.handleId;
                  // check whether handle is null, because some polyfill or browser
                  // may return undefined from setTimeout/setInterval/setImmediate/requestAnimationFrame
                  if (handle && handle.ref && handle.unref && typeof handle.ref === 'function' &&
                      typeof handle.unref === 'function') {
                      task.ref = handle.ref.bind(handle);
                      task.unref = handle.unref.bind(handle);
                  }
                  return task;
              }
              else {
                  // cause an error by calling it directly.
                  return delegate.apply(window, args);
              }
          }; });
      clearNative =
          patchMethod(window, cancelName, function (delegate) { return function (self, args) {
              var task = typeof args[0] === 'number' ? tasksByHandleId[args[0]] : args[0];
              if (task && typeof task.type === 'string') {
                  if (task.state !== 'notScheduled' &&
                      (task.cancelFn && task.data.isPeriodic || task.runCount === 0)) {
                      // Do not cancel already canceled functions
                      task.zone.cancelTask(task);
                  }
              }
              else {
                  // cause an error by calling it directly.
                  delegate.apply(window, args);
              }
          }; });
  }
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /*
   * This is necessary for Chrome and Chrome mobile, to enable
   * things like redefining `createdCallback` on an element.
   */
  var _defineProperty = Object[zoneSymbol('defineProperty')] = Object.defineProperty;
  var _getOwnPropertyDescriptor = Object[zoneSymbol('getOwnPropertyDescriptor')] =
      Object.getOwnPropertyDescriptor;
  var _create = Object.create;
  var unconfigurablesKey = zoneSymbol('unconfigurables');
  function propertyPatch() {
      Object.defineProperty = function (obj, prop, desc) {
          if (isUnconfigurable(obj, prop)) {
              throw new TypeError('Cannot assign to read only property \'' + prop + '\' of ' + obj);
          }
          var originalConfigurableFlag = desc.configurable;
          if (prop !== 'prototype') {
              desc = rewriteDescriptor(obj, prop, desc);
          }
          return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag);
      };
      Object.defineProperties = function (obj, props) {
          Object.keys(props).forEach(function (prop) {
              Object.defineProperty(obj, prop, props[prop]);
          });
          return obj;
      };
      Object.create = function (obj, proto) {
          if (typeof proto === 'object' && !Object.isFrozen(proto)) {
              Object.keys(proto).forEach(function (prop) {
                  proto[prop] = rewriteDescriptor(obj, prop, proto[prop]);
              });
          }
          return _create(obj, proto);
      };
      Object.getOwnPropertyDescriptor = function (obj, prop) {
          var desc = _getOwnPropertyDescriptor(obj, prop);
          if (isUnconfigurable(obj, prop)) {
              desc.configurable = false;
          }
          return desc;
      };
  }
  function _redefineProperty(obj, prop, desc) {
      var originalConfigurableFlag = desc.configurable;
      desc = rewriteDescriptor(obj, prop, desc);
      return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag);
  }
  function isUnconfigurable(obj, prop) {
      return obj && obj[unconfigurablesKey] && obj[unconfigurablesKey][prop];
  }
  function rewriteDescriptor(obj, prop, desc) {
      desc.configurable = true;
      if (!desc.configurable) {
          if (!obj[unconfigurablesKey]) {
              _defineProperty(obj, unconfigurablesKey, { writable: true, value: {} });
          }
          obj[unconfigurablesKey][prop] = true;
      }
      return desc;
  }
  function _tryDefineProperty(obj, prop, desc, originalConfigurableFlag) {
      try {
          return _defineProperty(obj, prop, desc);
      }
      catch (error) {
          if (desc.configurable) {
              // In case of errors, when the configurable flag was likely set by rewriteDescriptor(), let's
              // retry with the original flag value
              if (typeof originalConfigurableFlag == 'undefined') {
                  delete desc.configurable;
              }
              else {
                  desc.configurable = originalConfigurableFlag;
              }
              try {
                  return _defineProperty(obj, prop, desc);
              }
              catch (error) {
                  var descJson = null;
                  try {
                      descJson = JSON.stringify(desc);
                  }
                  catch (error) {
                      descJson = descJson.toString();
                  }
                  console.log("Attempting to configure '" + prop + "' with descriptor '" + descJson + "' on object '" + obj + "' and got error, giving up: " + error);
              }
          }
          else {
              throw error;
          }
      }
  }
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  var WTF_ISSUE_555 = 'Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video';
  var NO_EVENT_TARGET = 'ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket'
      .split(',');
  var EVENT_TARGET = 'EventTarget';
  function eventTargetPatch(_global) {
      var apis = [];
      var isWtf = _global['wtf'];
      if (isWtf) {
          // Workaround for: https://github.com/google/tracing-framework/issues/555
          apis = WTF_ISSUE_555.split(',').map(function (v) { return 'HTML' + v + 'Element'; }).concat(NO_EVENT_TARGET);
      }
      else if (_global[EVENT_TARGET]) {
          apis.push(EVENT_TARGET);
      }
      else {
          // Note: EventTarget is not available in all browsers,
          // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget
          apis = NO_EVENT_TARGET;
      }
      for (var i = 0; i < apis.length; i++) {
          var type = _global[apis[i]];
          patchEventTargetMethods(type && type.prototype);
      }
  }
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  // we have to patch the instance since the proto is non-configurable
  function apply(_global) {
      var WS = _global.WebSocket;
      // On Safari window.EventTarget doesn't exist so need to patch WS add/removeEventListener
      // On older Chrome, no need since EventTarget was already patched
      if (!_global.EventTarget) {
          patchEventTargetMethods(WS.prototype);
      }
      _global.WebSocket = function (a, b) {
          var socket = arguments.length > 1 ? new WS(a, b) : new WS(a);
          var proxySocket;
          // Safari 7.0 has non-configurable own 'onmessage' and friends properties on the socket instance
          var onmessageDesc = Object.getOwnPropertyDescriptor(socket, 'onmessage');
          if (onmessageDesc && onmessageDesc.configurable === false) {
              proxySocket = Object.create(socket);
              ['addEventListener', 'removeEventListener', 'send', 'close'].forEach(function (propName) {
                  proxySocket[propName] = function () {
                      return socket[propName].apply(socket, arguments);
                  };
              });
          }
          else {
              // we can patch the real socket
              proxySocket = socket;
          }
          patchOnProperties(proxySocket, ['close', 'error', 'message', 'open']);
          return proxySocket;
      };
      for (var prop in WS) {
          _global['WebSocket'][prop] = WS[prop];
      }
  }
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  var globalEventHandlersEventNames = [
      'abort',
      'animationcancel',
      'animationend',
      'animationiteration',
      'auxclick',
      'beforeinput',
      'blur',
      'cancel',
      'canplay',
      'canplaythrough',
      'change',
      'compositionstart',
      'compositionupdate',
      'compositionend',
      'cuechange',
      'click',
      'close',
      'contextmenu',
      'curechange',
      'dblclick',
      'drag',
      'dragend',
      'dragenter',
      'dragexit',
      'dragleave',
      'dragover',
      'drop',
      'durationchange',
      'emptied',
      'ended',
      'error',
      'focus',
      'focusin',
      'focusout',
      'gotpointercapture',
      'input',
      'invalid',
      'keydown',
      'keypress',
      'keyup',
      'load',
      'loadstart',
      'loadeddata',
      'loadedmetadata',
      'lostpointercapture',
      'mousedown',
      'mouseenter',
      'mouseleave',
      'mousemove',
      'mouseout',
      'mouseover',
      'mouseup',
      'mousewheel',
      'pause',
      'play',
      'playing',
      'pointercancel',
      'pointerdown',
      'pointerenter',
      'pointerleave',
      'pointerlockchange',
      'mozpointerlockchange',
      'webkitpointerlockerchange',
      'pointerlockerror',
      'mozpointerlockerror',
      'webkitpointerlockerror',
      'pointermove',
      'pointout',
      'pointerover',
      'pointerup',
      'progress',
      'ratechange',
      'reset',
      'resize',
      'scroll',
      'seeked',
      'seeking',
      'select',
      'selectionchange',
      'selectstart',
      'show',
      'sort',
      'stalled',
      'submit',
      'suspend',
      'timeupdate',
      'volumechange',
      'touchcancel',
      'touchmove',
      'touchstart',
      'transitioncancel',
      'transitionend',
      'waiting',
      'wheel'
  ];
  var documentEventNames = [
      'afterscriptexecute', 'beforescriptexecute', 'DOMContentLoaded', 'fullscreenchange',
      'mozfullscreenchange', 'webkitfullscreenchange', 'msfullscreenchange', 'fullscreenerror',
      'mozfullscreenerror', 'webkitfullscreenerror', 'msfullscreenerror', 'readystatechange'
  ];
  var windowEventNames = [
      'absolutedeviceorientation',
      'afterinput',
      'afterprint',
      'appinstalled',
      'beforeinstallprompt',
      'beforeprint',
      'beforeunload',
      'devicelight',
      'devicemotion',
      'deviceorientation',
      'deviceorientationabsolute',
      'deviceproximity',
      'hashchange',
      'languagechange',
      'message',
      'mozbeforepaint',
      'offline',
      'online',
      'paint',
      'pageshow',
      'pagehide',
      'popstate',
      'rejectionhandled',
      'storage',
      'unhandledrejection',
      'unload',
      'userproximity',
      'vrdisplyconnected',
      'vrdisplaydisconnected',
      'vrdisplaypresentchange'
  ];
  var htmlElementEventNames = [
      'beforecopy', 'beforecut', 'beforepaste', 'copy', 'cut', 'paste', 'dragstart', 'loadend',
      'animationstart', 'search', 'transitionrun', 'transitionstart', 'webkitanimationend',
      'webkitanimationiteration', 'webkitanimationstart', 'webkittransitionend'
  ];
  var mediaElementEventNames = ['encrypted', 'waitingforkey', 'msneedkey', 'mozinterruptbegin', 'mozinterruptend'];
  var ieElementEventNames = [
      'activate',
      'afterupdate',
      'ariarequest',
      'beforeactivate',
      'beforedeactivate',
      'beforeeditfocus',
      'beforeupdate',
      'cellchange',
      'controlselect',
      'dataavailable',
      'datasetchanged',
      'datasetcomplete',
      'errorupdate',
      'filterchange',
      'layoutcomplete',
      'losecapture',
      'move',
      'moveend',
      'movestart',
      'propertychange',
      'resizeend',
      'resizestart',
      'rowenter',
      'rowexit',
      'rowsdelete',
      'rowsinserted',
      'command',
      'compassneedscalibration',
      'deactivate',
      'help',
      'mscontentzoom',
      'msmanipulationstatechanged',
      'msgesturechange',
      'msgesturedoubletap',
      'msgestureend',
      'msgesturehold',
      'msgesturestart',
      'msgesturetap',
      'msgotpointercapture',
      'msinertiastart',
      'mslostpointercapture',
      'mspointercancel',
      'mspointerdown',
      'mspointerenter',
      'mspointerhover',
      'mspointerleave',
      'mspointermove',
      'mspointerout',
      'mspointerover',
      'mspointerup',
      'pointerout',
      'mssitemodejumplistitemremoved',
      'msthumbnailclick',
      'stop',
      'storagecommit'
  ];
  var webglEventNames = ['webglcontextrestored', 'webglcontextlost', 'webglcontextcreationerror'];
  var formEventNames = ['autocomplete', 'autocompleteerror'];
  var detailEventNames = ['toggle'];
  var frameEventNames = ['load'];
  var frameSetEventNames = ['blur', 'error', 'focus', 'load', 'resize', 'scroll'];
  var marqueeEventNames = ['bounce', 'finish', 'start'];
  var XMLHttpRequestEventNames = [
      'loadstart', 'progress', 'abort', 'error', 'load', 'progress', 'timeout', 'loadend',
      'readystatechange'
  ];
  var IDBIndexEventNames = ['upgradeneeded', 'complete', 'abort', 'success', 'error', 'blocked', 'versionchange', 'close'];
  var websocketEventNames = ['close', 'error', 'open', 'message'];
  var eventNames = globalEventHandlersEventNames.concat(webglEventNames, formEventNames, detailEventNames, documentEventNames, windowEventNames, htmlElementEventNames, ieElementEventNames);
  function propertyDescriptorPatch(_global) {
      if (isNode && !isMix) {
          return;
      }
      var supportsWebSocket = typeof WebSocket !== 'undefined';
      if (canPatchViaPropertyDescriptor()) {
          // for browsers that we can patch the descriptor:  Chrome & Firefox
          if (isBrowser) {
              // in IE/Edge, onProp not exist in window object, but in WindowPrototype
              // so we need to pass WindowPrototype to check onProp exist or not
              patchOnProperties(window, eventNames, Object.getPrototypeOf(window));
              patchOnProperties(Document.prototype, eventNames);
              if (typeof window['SVGElement'] !== 'undefined') {
                  patchOnProperties(window['SVGElement'].prototype, eventNames);
              }
              patchOnProperties(Element.prototype, eventNames);
              patchOnProperties(HTMLElement.prototype, eventNames);
              patchOnProperties(HTMLMediaElement.prototype, mediaElementEventNames);
              patchOnProperties(HTMLFrameSetElement.prototype, windowEventNames.concat(frameSetEventNames));
              patchOnProperties(HTMLBodyElement.prototype, windowEventNames.concat(frameSetEventNames));
              patchOnProperties(HTMLFrameElement.prototype, frameEventNames);
              patchOnProperties(HTMLIFrameElement.prototype, frameEventNames);
              var HTMLMarqueeElement_1 = window['HTMLMarqueeElement'];
              if (HTMLMarqueeElement_1) {
                  patchOnProperties(HTMLMarqueeElement_1.prototype, marqueeEventNames);
              }
          }
          patchOnProperties(XMLHttpRequest.prototype, XMLHttpRequestEventNames);
          var XMLHttpRequestEventTarget = _global['XMLHttpRequestEventTarget'];
          if (XMLHttpRequestEventTarget) {
              patchOnProperties(XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype, XMLHttpRequestEventNames);
          }
          if (typeof IDBIndex !== 'undefined') {
              patchOnProperties(IDBIndex.prototype, IDBIndexEventNames);
              patchOnProperties(IDBRequest.prototype, IDBIndexEventNames);
              patchOnProperties(IDBOpenDBRequest.prototype, IDBIndexEventNames);
              patchOnProperties(IDBDatabase.prototype, IDBIndexEventNames);
              patchOnProperties(IDBTransaction.prototype, IDBIndexEventNames);
              patchOnProperties(IDBCursor.prototype, IDBIndexEventNames);
          }
          if (supportsWebSocket) {
              patchOnProperties(WebSocket.prototype, websocketEventNames);
          }
      }
      else {
          // Safari, Android browsers (Jelly Bean)
          patchViaCapturingAllTheEvents();
          patchClass('XMLHttpRequest');
          if (supportsWebSocket) {
              apply(_global);
          }
      }
  }
  function canPatchViaPropertyDescriptor() {
      if ((isBrowser || isMix) && !Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'onclick') &&
          typeof Element !== 'undefined') {
          // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364
          // IDL interface attributes are not configurable
          var desc = Object.getOwnPropertyDescriptor(Element.prototype, 'onclick');
          if (desc && !desc.configurable)
              return false;
      }
      var xhrDesc = Object.getOwnPropertyDescriptor(XMLHttpRequest.prototype, 'onreadystatechange');
      // add enumerable and configurable here because in opera
      // by default XMLHttpRequest.prototype.onreadystatechange is undefined
      // without adding enumerable and configurable will cause onreadystatechange
      // non-configurable
      // and if XMLHttpRequest.prototype.onreadystatechange is undefined,
      // we should set a real desc instead a fake one
      if (xhrDesc) {
          Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', {
              enumerable: true,
              configurable: true,
              get: function () {
                  return true;
              }
          });
          var req = new XMLHttpRequest();
          var result = !!req.onreadystatechange;
          // restore original desc
          Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', xhrDesc || {});
          return result;
      }
      else {
          Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', {
              enumerable: true,
              configurable: true,
              get: function () {
                  return this[zoneSymbol('fakeonreadystatechange')];
              },
              set: function (value) {
                  this[zoneSymbol('fakeonreadystatechange')] = value;
              }
          });
          var req = new XMLHttpRequest();
          var detectFunc = function () { };
          req.onreadystatechange = detectFunc;
          var result = req[zoneSymbol('fakeonreadystatechange')] === detectFunc;
          req.onreadystatechange = null;
          return result;
      }
  }
  
  var unboundKey = zoneSymbol('unbound');
  // Whenever any eventListener fires, we check the eventListener target and all parents
  // for `onwhatever` properties and replace them with zone-bound functions
  // - Chrome (for now)
  function patchViaCapturingAllTheEvents() {
      var _loop_1 = function (i) {
          var property = eventNames[i];
          var onproperty = 'on' + property;
          self.addEventListener(property, function (event) {
              var elt = event.target, bound, source;
              if (elt) {
                  source = elt.constructor['name'] + '.' + onproperty;
              }
              else {
                  source = 'unknown.' + onproperty;
              }
              while (elt) {
                  if (elt[onproperty] && !elt[onproperty][unboundKey]) {
                      bound = Zone.current.wrap(elt[onproperty], source);
                      bound[unboundKey] = elt[onproperty];
                      elt[onproperty] = bound;
                  }
                  elt = elt.parentElement;
              }
          }, true);
      };
      for (var i = 0; i < eventNames.length; i++) {
          _loop_1(i);
      }
  }
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  function registerElementPatch(_global) {
      if ((!isBrowser && !isMix) || !('registerElement' in _global.document)) {
          return;
      }
      var _registerElement = document.registerElement;
      var callbacks = ['createdCallback', 'attachedCallback', 'detachedCallback', 'attributeChangedCallback'];
      document.registerElement = function (name, opts) {
          if (opts && opts.prototype) {
              callbacks.forEach(function (callback) {
                  var source = 'Document.registerElement::' + callback;
                  if (opts.prototype.hasOwnProperty(callback)) {
                      var descriptor = Object.getOwnPropertyDescriptor(opts.prototype, callback);
                      if (descriptor && descriptor.value) {
                          descriptor.value = Zone.current.wrap(descriptor.value, source);
                          _redefineProperty(opts.prototype, callback, descriptor);
                      }
                      else {
                          opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source);
                      }
                  }
                  else if (opts.prototype[callback]) {
                      opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source);
                  }
              });
          }
          return _registerElement.apply(document, [name, opts]);
      };
      attachOriginToPatched(document.registerElement, _registerElement);
  }
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  Zone.__load_patch('timers', function (global, Zone, api) {
      var set = 'set';
      var clear = 'clear';
      patchTimer(global, set, clear, 'Timeout');
      patchTimer(global, set, clear, 'Interval');
      patchTimer(global, set, clear, 'Immediate');
      patchTimer(global, 'request', 'cancel', 'AnimationFrame');
      patchTimer(global, 'mozRequest', 'mozCancel', 'AnimationFrame');
      patchTimer(global, 'webkitRequest', 'webkitCancel', 'AnimationFrame');
  });
  Zone.__load_patch('blocking', function (global, Zone, api) {
      var blockingMethods = ['alert', 'prompt', 'confirm'];
      for (var i = 0; i < blockingMethods.length; i++) {
          var name_1 = blockingMethods[i];
          patchMethod(global, name_1, function (delegate, symbol, name) {
              return function (s, args) {
                  return Zone.current.run(delegate, global, args, name);
              };
          });
      }
  });
  Zone.__load_patch('EventTarget', function (global, Zone, api) {
      eventTargetPatch(global);
      // patch XMLHttpRequestEventTarget's addEventListener/removeEventListener
      var XMLHttpRequestEventTarget = global['XMLHttpRequestEventTarget'];
      if (XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype) {
          patchEventTargetMethods(XMLHttpRequestEventTarget.prototype);
      }
      patchClass('MutationObserver');
      patchClass('WebKitMutationObserver');
      patchClass('FileReader');
  });
  Zone.__load_patch('on_property', function (global, Zone, api) {
      propertyDescriptorPatch(global);
      propertyPatch();
      registerElementPatch(global);
  });
  Zone.__load_patch('XHR', function (global, Zone, api) {
      // Treat XMLHTTPRequest as a macrotask.
      patchXHR(global);
      var XHR_TASK = zoneSymbol('xhrTask');
      var XHR_SYNC = zoneSymbol('xhrSync');
      var XHR_LISTENER = zoneSymbol('xhrListener');
      var XHR_SCHEDULED = zoneSymbol('xhrScheduled');
      function patchXHR(window) {
          function findPendingTask(target) {
              var pendingTask = target[XHR_TASK];
              return pendingTask;
          }
          function scheduleTask(task) {
              XMLHttpRequest[XHR_SCHEDULED] = false;
              var data = task.data;
              // remove existing event listener
              var listener = data.target[XHR_LISTENER];
              if (listener) {
                  data.target.removeEventListener('readystatechange', listener);
              }
              var newListener = data.target[XHR_LISTENER] = function () {
                  if (data.target.readyState === data.target.DONE) {
                      // sometimes on some browsers XMLHttpRequest will fire onreadystatechange with
                      // readyState=4 multiple times, so we need to check task state here
                      if (!data.aborted && XMLHttpRequest[XHR_SCHEDULED] &&
                          task.state === 'scheduled') {
                          task.invoke();
                      }
                  }
              };
              data.target.addEventListener('readystatechange', newListener);
              var storedTask = data.target[XHR_TASK];
              if (!storedTask) {
                  data.target[XHR_TASK] = task;
              }
              sendNative.apply(data.target, data.args);
              XMLHttpRequest[XHR_SCHEDULED] = true;
              return task;
          }
          function placeholderCallback() { }
          function clearTask(task) {
              var data = task.data;
              // Note - ideally, we would call data.target.removeEventListener here, but it's too late
              // to prevent it from firing. So instead, we store info for the event listener.
              data.aborted = true;
              return abortNative.apply(data.target, data.args);
          }
          var openNative = patchMethod(window.XMLHttpRequest.prototype, 'open', function () { return function (self, args) {
              self[XHR_SYNC] = args[2] == false;
              return openNative.apply(self, args);
          }; });
          var sendNative = patchMethod(window.XMLHttpRequest.prototype, 'send', function () { return function (self, args) {
              var zone = Zone.current;
              if (self[XHR_SYNC]) {
                  // if the XHR is sync there is no task to schedule, just execute the code.
                  return sendNative.apply(self, args);
              }
              else {
                  var options = { target: self, isPeriodic: false, delay: null, args: args, aborted: false };
                  return zone.scheduleMacroTask('XMLHttpRequest.send', placeholderCallback, options, scheduleTask, clearTask);
              }
          }; });
          var abortNative = patchMethod(window.XMLHttpRequest.prototype, 'abort', function (delegate) { return function (self, args) {
              var task = findPendingTask(self);
              if (task && typeof task.type == 'string') {
                  // If the XHR has already completed, do nothing.
                  // If the XHR has already been aborted, do nothing.
                  // Fix #569, call abort multiple times before done will cause
                  // macroTask task count be negative number
                  if (task.cancelFn == null || (task.data && task.data.aborted)) {
                      return;
                  }
                  task.zone.cancelTask(task);
              }
              // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no
              // task
              // to cancel. Do nothing.
          }; });
      }
  });
  Zone.__load_patch('geolocation', function (global, Zone, api) {
      /// GEO_LOCATION
      if (global['navigator'] && global['navigator'].geolocation) {
          patchPrototype(global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']);
      }
  });
  Zone.__load_patch('PromiseRejectionEvent', function (global, Zone, api) {
      // handle unhandled promise rejection
      function findPromiseRejectionHandler(evtName) {
          return function (e) {
              var eventTasks = findEventTask(global, evtName);
              eventTasks.forEach(function (eventTask) {
                  // windows has added unhandledrejection event listener
                  // trigger the event listener
                  var PromiseRejectionEvent = global['PromiseRejectionEvent'];
                  if (PromiseRejectionEvent) {
                      var evt = new PromiseRejectionEvent(evtName, { promise: e.promise, reason: e.rejection });
                      eventTask.invoke(evt);
                  }
              });
          };
      }
      if (global['PromiseRejectionEvent']) {
          Zone[zoneSymbol('unhandledPromiseRejectionHandler')] =
              findPromiseRejectionHandler('unhandledrejection');
          Zone[zoneSymbol('rejectionHandledHandler')] =
              findPromiseRejectionHandler('rejectionhandled');
      }
  });
  Zone.__load_patch('util', function (global, Zone, api) {
      api.patchEventTargetMethods = patchEventTargetMethods;
      api.patchOnProperties = patchOnProperties;
  });
  
  /**
   * @license
   * Copyright Google Inc. All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  
  })));
  
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(26)))
  
  /***/ }),
  /* 381 */,
  /* 382 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__(176);
  
  
  /***/ })
  ],[382]);
  //# sourceMappingURL=polyfills.bundle.js.map