165 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; });

   219 function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }

   220 

   679         type: "button",

   848 /**

   849  * Copyright (c) 2014-present, Facebook, Inc.

   850  *

   851  * This source code is licensed under the MIT license found in the

   852  * LICENSE file in the root directory of this source tree.

   853  */

   854 

   855 !(function(global) {

   856   "use strict";

   857 

   858   var Op = Object.prototype;

   859   var hasOwn = Op.hasOwnProperty;

   860   var undefined; // More compressible than void 0.

   861   var $Symbol = typeof Symbol === "function" ? Symbol : {};

   862   var iteratorSymbol = $Symbol.iterator || "@@iterator";

   863   var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";

   864   var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";

   865 

   866   var inModule = typeof module === "object";

   867   var runtime = global.regeneratorRuntime;

   868   if (runtime) {

   869     if (inModule) {

   870       // If regeneratorRuntime is defined globally and we're in a module,

   871       // make the exports object identical to regeneratorRuntime.

   872       module.exports = runtime;

   873     }

   874     // Don't bother evaluating the rest of this file if the runtime was

   875     // already defined globally.

   876     return;

   877   }

   878 

   879   // Define the runtime globally (as expected by generated code) as either

   880   // module.exports (if we're in a module) or a new, empty object.

   881   runtime = global.regeneratorRuntime = inModule ? module.exports : {};

   882 

   883   function wrap(innerFn, outerFn, self, tryLocsList) {

   884     // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.

   885     var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;

   886     var generator = Object.create(protoGenerator.prototype);

   887     var context = new Context(tryLocsList || []);

   888 

   889     // The ._invoke method unifies the implementations of the .next,

   890     // .throw, and .return methods.

   891     generator._invoke = makeInvokeMethod(innerFn, self, context);

   892 

   893     return generator;

   894   }

   895   runtime.wrap = wrap;

   896 

   897   // Try/catch helper to minimize deoptimizations. Returns a completion

   898   // record like context.tryEntries[i].completion. This interface could

   899   // have been (and was previously) designed to take a closure to be

   900   // invoked without arguments, but in all the cases we care about we

   901   // already have an existing method we want to call, so there's no need

   902   // to create a new function object. We can even get away with assuming

   903   // the method takes exactly one argument, since that happens to be true

   904   // in every case, so we don't have to touch the arguments object. The

   905   // only additional allocation required is the completion record, which

   906   // has a stable shape and so hopefully should be cheap to allocate.

   907   function tryCatch(fn, obj, arg) {

   908     try {

   909       return { type: "normal", arg: fn.call(obj, arg) };

   910     } catch (err) {

   911       return { type: "throw", arg: err };

   912     }

   913   }

   914 

   915   var GenStateSuspendedStart = "suspendedStart";

   916   var GenStateSuspendedYield = "suspendedYield";

   917   var GenStateExecuting = "executing";

   918   var GenStateCompleted = "completed";

   919 

   920   // Returning this object from the innerFn has the same effect as

   921   // breaking out of the dispatch switch statement.

   922   var ContinueSentinel = {};

   923 

   924   // Dummy constructor functions that we use as the .constructor and

   925   // .constructor.prototype properties for functions that return Generator

   926   // objects. For full spec compliance, you may wish to configure your

   927   // minifier not to mangle the names of these two functions.

   928   function Generator() {}

   929   function GeneratorFunction() {}

   930   function GeneratorFunctionPrototype() {}

   931 

   932   // This is a polyfill for %IteratorPrototype% for environments that

   933   // don't natively support it.

   934   var IteratorPrototype = {};

   935   IteratorPrototype[iteratorSymbol] = function () {

   936     return this;

   937   };

   938 

   939   var getProto = Object.getPrototypeOf;

   940   var NativeIteratorPrototype = getProto && getProto(getProto(values([])));

   941   if (NativeIteratorPrototype &&

   942       NativeIteratorPrototype !== Op &&

   943       hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {

   944     // This environment has a native %IteratorPrototype%; use it instead

   945     // of the polyfill.

   946     IteratorPrototype = NativeIteratorPrototype;

   947   }

   948 

   949   var Gp = GeneratorFunctionPrototype.prototype =

   950     Generator.prototype = Object.create(IteratorPrototype);

   951   GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;

   952   GeneratorFunctionPrototype.constructor = GeneratorFunction;

   953   GeneratorFunctionPrototype[toStringTagSymbol] =

   954     GeneratorFunction.displayName = "GeneratorFunction";

   955 

   956   // Helper for defining the .next, .throw, and .return methods of the

   957   // Iterator interface in terms of a single ._invoke method.

   958   function defineIteratorMethods(prototype) {

   959     ["next", "throw", "return"].forEach(function(method) {

   960       prototype[method] = function(arg) {

   961         return this._invoke(method, arg);

   962       };

   963     });

   964   }

   965 

   966   runtime.isGeneratorFunction = function(genFun) {

   967     var ctor = typeof genFun === "function" && genFun.constructor;

   968     return ctor

   969       ? ctor === GeneratorFunction ||

   970         // For the native GeneratorFunction constructor, the best we can

   971         // do is to check its .name property.

   972         (ctor.displayName || ctor.name) === "GeneratorFunction"

   973       : false;

   974   };

   975 

   976   runtime.mark = function(genFun) {

   977     if (Object.setPrototypeOf) {

   978       Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);

   979     } else {

   980       genFun.__proto__ = GeneratorFunctionPrototype;

   981       if (!(toStringTagSymbol in genFun)) {

   982         genFun[toStringTagSymbol] = "GeneratorFunction";

   983       }

   984     }

   985     genFun.prototype = Object.create(Gp);

   986     return genFun;

   987   };

   988 

   989   // Within the body of any async function, `await x` is transformed to

   990   // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test

   991   // `hasOwn.call(value, "__await")` to determine if the yielded value is

   992   // meant to be awaited.

   993   runtime.awrap = function(arg) {

   994     return { __await: arg };

   995   };

   996 

   997   function AsyncIterator(generator) {

   998     function invoke(method, arg, resolve, reject) {

   999       var record = tryCatch(generator[method], generator, arg);

  1000       if (record.type === "throw") {

  1001         reject(record.arg);

  1002       } else {

  1003         var result = record.arg;

  1004         var value = result.value;

  1005         if (value &&

  1006             typeof value === "object" &&

  1007             hasOwn.call(value, "__await")) {

  1008           return Promise.resolve(value.__await).then(function(value) {

  1009             invoke("next", value, resolve, reject);

  1010           }, function(err) {

  1011             invoke("throw", err, resolve, reject);

  1012           });

  1013         }

  1014 

  1015         return Promise.resolve(value).then(function(unwrapped) {

  1016           // When a yielded Promise is resolved, its final value becomes

  1017           // the .value of the Promise<{value,done}> result for the

  1018           // current iteration.

  1019           result.value = unwrapped;

  1020           resolve(result);

  1021         }, function(error) {

  1022           // If a rejected Promise was yielded, throw the rejection back

  1023           // into the async generator function so it can be handled there.

  1024           return invoke("throw", error, resolve, reject);

  1025         });

  1026       }

  1027     }

  1028 

  1029     var previousPromise;

  1030 

  1031     function enqueue(method, arg) {

  1032       function callInvokeWithMethodAndArg() {

  1033         return new Promise(function(resolve, reject) {

  1034           invoke(method, arg, resolve, reject);

  1035         });

  1036       }

  1037 

  1038       return previousPromise =

  1039         // If enqueue has been called before, then we want to wait until

  1040         // all previous Promises have been resolved before calling invoke,

  1041         // so that results are always delivered in the correct order. If

  1042         // enqueue has not been called before, then it is important to

  1043         // call invoke immediately, without waiting on a callback to fire,

  1044         // so that the async generator function has the opportunity to do

  1045         // any necessary setup in a predictable way. This predictability

  1046         // is why the Promise constructor synchronously invokes its

  1047         // executor callback, and why async functions synchronously

  1048         // execute code before the first await. Since we implement simple

  1049         // async functions in terms of async generators, it is especially

  1050         // important to get this right, even though it requires care.

  1051         previousPromise ? previousPromise.then(

  1052           callInvokeWithMethodAndArg,

  1053           // Avoid propagating failures to Promises returned by later

  1054           // invocations of the iterator.

  1055           callInvokeWithMethodAndArg

  1056         ) : callInvokeWithMethodAndArg();

  1057     }

  1058 

  1059     // Define the unified helper method that is used to implement .next,

  1060     // .throw, and .return (see defineIteratorMethods).

  1061     this._invoke = enqueue;

  1062   }

  1063 

  1064   defineIteratorMethods(AsyncIterator.prototype);

  1065   AsyncIterator.prototype[asyncIteratorSymbol] = function () {

  1066     return this;

  1067   };

  1068   runtime.AsyncIterator = AsyncIterator;

  1069 

  1070   // Note that simple async functions are implemented on top of

  1071   // AsyncIterator objects; they just return a Promise for the value of

  1072   // the final result produced by the iterator.

  1073   runtime.async = function(innerFn, outerFn, self, tryLocsList) {

  1074     var iter = new AsyncIterator(

  1075       wrap(innerFn, outerFn, self, tryLocsList)

  1076     );

  1077 

  1078     return runtime.isGeneratorFunction(outerFn)

  1079       ? iter // If outerFn is a generator, return the full iterator.

  1080       : iter.next().then(function(result) {

  1081           return result.done ? result.value : iter.next();

  1082         });

  1083   };

  1084 

  1085   function makeInvokeMethod(innerFn, self, context) {

  1086     var state = GenStateSuspendedStart;

  1087 

  1088     return function invoke(method, arg) {

  1089       if (state === GenStateExecuting) {

  1090         throw new Error("Generator is already running");

  1091       }

  1092 

  1093       if (state === GenStateCompleted) {

  1094         if (method === "throw") {

  1095           throw arg;

  1096         }

  1097 

  1098         // Be forgiving, per 25.3.3.3.3 of the spec:

  1099         // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume

  1100         return doneResult();

  1101       }

  1102 

  1103       context.method = method;

  1104       context.arg = arg;

  1105 

  1106       while (true) {

  1107         var delegate = context.delegate;

  1108         if (delegate) {

  1109           var delegateResult = maybeInvokeDelegate(delegate, context);

  1110           if (delegateResult) {

  1111             if (delegateResult === ContinueSentinel) continue;

  1112             return delegateResult;

  1113           }

  1114         }

  1115 

  1116         if (context.method === "next") {

  1117           // Setting context._sent for legacy support of Babel's

  1118           // function.sent implementation.

  1119           context.sent = context._sent = context.arg;

  1120 

  1121         } else if (context.method === "throw") {

  1122           if (state === GenStateSuspendedStart) {

  1123             state = GenStateCompleted;

  1124             throw context.arg;

  1125           }

  1126 

  1127           context.dispatchException(context.arg);

  1128 

  1129         } else if (context.method === "return") {

  1130           context.abrupt("return", context.arg);

  1131         }

  1132 

  1133         state = GenStateExecuting;

  1134 

  1135         var record = tryCatch(innerFn, self, context);

  1136         if (record.type === "normal") {

  1137           // If an exception is thrown from innerFn, we leave state ===

  1138           // GenStateExecuting and loop back for another invocation.

  1139           state = context.done

  1140             ? GenStateCompleted

  1141             : GenStateSuspendedYield;

  1142 

  1143           if (record.arg === ContinueSentinel) {

  1144             continue;

  1145           }

  1146 

  1147           return {

  1148             value: record.arg,

  1149             done: context.done

  1150           };

  1151 

  1152         } else if (record.type === "throw") {

  1153           state = GenStateCompleted;

  1154           // Dispatch the exception by looping back around to the

  1155           // context.dispatchException(context.arg) call above.

  1156           context.method = "throw";

  1157           context.arg = record.arg;

  1158         }

  1159       }

  1160     };

  1161   }

  1162 

  1163   // Call delegate.iterator[context.method](context.arg) and handle the

  1164   // result, either by returning a { value, done } result from the

  1165   // delegate iterator, or by modifying context.method and context.arg,

  1166   // setting context.delegate to null, and returning the ContinueSentinel.

  1167   function maybeInvokeDelegate(delegate, context) {

  1168     var method = delegate.iterator[context.method];

  1169     if (method === undefined) {

  1170       // A .throw or .return when the delegate iterator has no .throw

  1171       // method always terminates the yield* loop.

  1172       context.delegate = null;

  1173 

  1174       if (context.method === "throw") {

  1175         if (delegate.iterator.return) {

  1176           // If the delegate iterator has a return method, give it a

  1177           // chance to clean up.

  1178           context.method = "return";

  1179           context.arg = undefined;

  1180           maybeInvokeDelegate(delegate, context);

  1181 

  1182           if (context.method === "throw") {

  1183             // If maybeInvokeDelegate(context) changed context.method from

  1184             // "return" to "throw", let that override the TypeError below.

  1185             return ContinueSentinel;

  1186           }

  1187         }

  1188 

  1189         context.method = "throw";

  1190         context.arg = new TypeError(

  1191           "The iterator does not provide a 'throw' method");

  1192       }

  1193 

  1194       return ContinueSentinel;

  1195     }

  1196 

  1197     var record = tryCatch(method, delegate.iterator, context.arg);

  1198 

  1199     if (record.type === "throw") {

  1200       context.method = "throw";

  1201       context.arg = record.arg;

  1202       context.delegate = null;

  1203       return ContinueSentinel;

  1204     }

  1205 

  1206     var info = record.arg;

  1207 

  1208     if (! info) {

  1209       context.method = "throw";

  1210       context.arg = new TypeError("iterator result is not an object");

  1211       context.delegate = null;

  1212       return ContinueSentinel;

  1213     }

  1214 

  1215     if (info.done) {

  1216       // Assign the result of the finished delegate to the temporary

  1217       // variable specified by delegate.resultName (see delegateYield).

  1218       context[delegate.resultName] = info.value;

  1219 

  1220       // Resume execution at the desired location (see delegateYield).

  1221       context.next = delegate.nextLoc;

  1222 

  1223       // If context.method was "throw" but the delegate handled the

  1224       // exception, let the outer generator proceed normally. If

  1225       // context.method was "next", forget context.arg since it has been

  1226       // "consumed" by the delegate iterator. If context.method was

  1227       // "return", allow the original .return call to continue in the

  1228       // outer generator.

  1229       if (context.method !== "return") {

  1230         context.method = "next";

  1231         context.arg = undefined;

  1232       }

  1233 

  1234     } else {

  1235       // Re-yield the result returned by the delegate method.

  1236       return info;

  1237     }

  1238 

  1239     // The delegate iterator is finished, so forget it and continue with

  1240     // the outer generator.

  1241     context.delegate = null;

  1242     return ContinueSentinel;

  1243   }

  1244 

  1245   // Define Generator.prototype.{next,throw,return} in terms of the

  1246   // unified ._invoke helper method.

  1247   defineIteratorMethods(Gp);

  1248 

  1249   Gp[toStringTagSymbol] = "Generator";

  1250 

  1251   // A Generator should always return itself as the iterator object when the

  1252   // @@iterator function is called on it. Some browsers' implementations of the

  1253   // iterator prototype chain incorrectly implement this, causing the Generator

  1254   // object to not be returned from this call. This ensures that doesn't happen.

  1255   // See https://github.com/facebook/regenerator/issues/274 for more details.

  1256   Gp[iteratorSymbol] = function() {

  1257     return this;

  1258   };

  1259 

  1260   Gp.toString = function() {

  1261     return "[object Generator]";

  1262   };

  1263 

  1264   function pushTryEntry(locs) {

  1265     var entry = { tryLoc: locs[0] };

  1266 

  1267     if (1 in locs) {

  1268       entry.catchLoc = locs[1];

  1269     }

  1270 

  1271     if (2 in locs) {

  1272       entry.finallyLoc = locs[2];

  1273       entry.afterLoc = locs[3];

  1274     }

  1275 

  1276     this.tryEntries.push(entry);

  1277   }

  1278 

  1279   function resetTryEntry(entry) {

  1280     var record = entry.completion || {};

  1281     record.type = "normal";

  1282     delete record.arg;

  1283     entry.completion = record;

  1284   }

  1285 

  1286   function Context(tryLocsList) {

  1287     // The root entry object (effectively a try statement without a catch

  1288     // or a finally block) gives us a place to store values thrown from

  1289     // locations where there is no enclosing try statement.

  1290     this.tryEntries = [{ tryLoc: "root" }];

  1291     tryLocsList.forEach(pushTryEntry, this);

  1292     this.reset(true);

  1293   }

  1294 

  1295   runtime.keys = function(object) {

  1296     var keys = [];

  1297     for (var key in object) {

  1298       keys.push(key);

  1299     }

  1300     keys.reverse();

  1301 

  1302     // Rather than returning an object with a next method, we keep

  1303     // things simple and return the next function itself.

  1304     return function next() {

  1305       while (keys.length) {

  1306         var key = keys.pop();

  1307         if (key in object) {

  1308           next.value = key;

  1309           next.done = false;

  1310           return next;

  1311         }

  1312       }

  1313 

  1314       // To avoid creating an additional object, we just hang the .value

  1315       // and .done properties off the next function object itself. This

  1316       // also ensures that the minifier will not anonymize the function.

  1317       next.done = true;

  1318       return next;

  1319     };

  1320   };

  1321 

  1322   function values(iterable) {

  1323     if (iterable) {

  1324       var iteratorMethod = iterable[iteratorSymbol];

  1325       if (iteratorMethod) {

  1326         return iteratorMethod.call(iterable);

  1327       }

  1328 

  1329       if (typeof iterable.next === "function") {

  1330         return iterable;

  1331       }

  1332 

  1333       if (!isNaN(iterable.length)) {

  1334         var i = -1, next = function next() {

  1335           while (++i < iterable.length) {

  1336             if (hasOwn.call(iterable, i)) {

  1337               next.value = iterable[i];

  1338               next.done = false;

  1339               return next;

  1340             }

  1341           }

  1342 

  1343           next.value = undefined;

  1344           next.done = true;

  1345 

  1346           return next;

  1347         };

  1348 

  1349         return next.next = next;

  1350       }

  1351     }

  1352 

  1353     // Return an iterator with no values.

  1354     return { next: doneResult };

  1355   }

  1356   runtime.values = values;

  1357 

  1358   function doneResult() {

  1359     return { value: undefined, done: true };

  1360   }

  1361 

  1362   Context.prototype = {

  1363     constructor: Context,

  1364 

  1365     reset: function(skipTempReset) {

  1366       this.prev = 0;

  1367       this.next = 0;

  1368       // Resetting context._sent for legacy support of Babel's

  1369       // function.sent implementation.

  1370       this.sent = this._sent = undefined;

  1371       this.done = false;

  1372       this.delegate = null;

  1373 

  1374       this.method = "next";

  1375       this.arg = undefined;

  1376 

  1377       this.tryEntries.forEach(resetTryEntry);

  1378 

  1379       if (!skipTempReset) {

  1380         for (var name in this) {

  1381           // Not sure about the optimal order of these conditions:

  1382           if (name.charAt(0) === "t" &&

  1383               hasOwn.call(this, name) &&

  1384               !isNaN(+name.slice(1))) {

  1385             this[name] = undefined;

  1386           }

  1387         }

  1388       }

  1389     },

  1390 

  1391     stop: function() {

  1392       this.done = true;

  1393 

  1394       var rootEntry = this.tryEntries[0];

  1395       var rootRecord = rootEntry.completion;

  1396       if (rootRecord.type === "throw") {

  1397         throw rootRecord.arg;

  1398       }

  1399 

  1400       return this.rval;

  1401     },

  1402 

  1403     dispatchException: function(exception) {

  1404       if (this.done) {

  1405         throw exception;

  1406       }

  1407 

  1408       var context = this;

  1409       function handle(loc, caught) {

  1410         record.type = "throw";

  1411         record.arg = exception;

  1412         context.next = loc;

  1413 

  1414         if (caught) {

  1415           // If the dispatched exception was caught by a catch block,

  1416           // then let that catch block handle the exception normally.

  1417           context.method = "next";

  1418           context.arg = undefined;

  1419         }

  1420 

  1421         return !! caught;

  1422       }

  1423 

  1424       for (var i = this.tryEntries.length - 1; i >= 0; --i) {

  1425         var entry = this.tryEntries[i];

  1426         var record = entry.completion;

  1427 

  1428         if (entry.tryLoc === "root") {

  1429           // Exception thrown outside of any try block that could handle

  1430           // it, so set the completion value of the entire function to

  1431           // throw the exception.

  1432           return handle("end");

  1433         }

  1434 

  1435         if (entry.tryLoc <= this.prev) {

  1436           var hasCatch = hasOwn.call(entry, "catchLoc");

  1437           var hasFinally = hasOwn.call(entry, "finallyLoc");

  1438 

  1439           if (hasCatch && hasFinally) {

  1440             if (this.prev < entry.catchLoc) {

  1441               return handle(entry.catchLoc, true);

  1442             } else if (this.prev < entry.finallyLoc) {

  1443               return handle(entry.finallyLoc);

  1444             }

  1445 

  1446           } else if (hasCatch) {

  1447             if (this.prev < entry.catchLoc) {

  1448               return handle(entry.catchLoc, true);

  1449             }

  1450 

  1451           } else if (hasFinally) {

  1452             if (this.prev < entry.finallyLoc) {

  1453               return handle(entry.finallyLoc);

  1454             }

  1455 

  1456           } else {

  1457             throw new Error("try statement without catch or finally");

  1458           }

  1459         }

  1460       }

  1461     },

  1462 

  1463     abrupt: function(type, arg) {

  1464       for (var i = this.tryEntries.length - 1; i >= 0; --i) {

  1465         var entry = this.tryEntries[i];

  1466         if (entry.tryLoc <= this.prev &&

  1467             hasOwn.call(entry, "finallyLoc") &&

  1468             this.prev < entry.finallyLoc) {

  1469           var finallyEntry = entry;

  1470           break;

  1471         }

  1472       }

  1473 

  1474       if (finallyEntry &&

  1475           (type === "break" ||

  1476            type === "continue") &&

  1477           finallyEntry.tryLoc <= arg &&

  1478           arg <= finallyEntry.finallyLoc) {

  1479         // Ignore the finally entry if control is not jumping to a

  1480         // location outside the try/catch block.

  1481         finallyEntry = null;

  1482       }

  1483 

  1484       var record = finallyEntry ? finallyEntry.completion : {};

  1485       record.type = type;

  1486       record.arg = arg;

  1487 

  1488       if (finallyEntry) {

  1489         this.method = "next";

  1490         this.next = finallyEntry.finallyLoc;