1(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[16],{ 2 3/***/ 1218: 4/***/ (function(module, exports, __webpack_require__) { 5 6"use strict"; 7 8 9exports.__esModule = true; 10exports.default = createWebStorage; 11 12var _getStorage = _interopRequireDefault(__webpack_require__(1219)); 13 14function _interopRequireDefault(obj) { 15 return obj && obj.__esModule ? obj : { 16 default: obj 17 }; 18} 19 20function createWebStorage(type) { 21 var storage = (0, _getStorage.default)(type); 22 return { 23 getItem: function getItem(key) { 24 return new Promise(function (resolve, reject) { 25 resolve(storage.getItem(key)); 26 }); 27 }, 28 setItem: function setItem(key, item) { 29 return new Promise(function (resolve, reject) { 30 resolve(storage.setItem(key, item)); 31 }); 32 }, 33 removeItem: function removeItem(key) { 34 return new Promise(function (resolve, reject) { 35 resolve(storage.removeItem(key)); 36 }); 37 } 38 }; 39} 40 41/***/ }), 42 43/***/ 1219: 44/***/ (function(module, exports, __webpack_require__) { 45 46"use strict"; 47 48 49exports.__esModule = true; 50exports.default = getStorage; 51 52function _typeof(obj) { 53 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 54 _typeof = function _typeof(obj) { 55 return typeof obj; 56 }; 57 } else { 58 _typeof = function _typeof(obj) { 59 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 60 }; 61 } 62 63 return _typeof(obj); 64} 65 66function noop() {} 67 68var noopStorage = { 69 getItem: noop, 70 setItem: noop, 71 removeItem: noop 72}; 73 74function hasStorage(storageType) { 75 if ((typeof self === "undefined" ? "undefined" : _typeof(self)) !== 'object' || !(storageType in self)) { 76 return false; 77 } 78 79 try { 80 var storage = self[storageType]; 81 var testKey = "redux-persist ".concat(storageType, " test"); 82 storage.setItem(testKey, 'test'); 83 storage.getItem(testKey); 84 storage.removeItem(testKey); 85 } catch (e) { 86 if (false) {} 87 return false; 88 } 89 90 return true; 91} 92 93function getStorage(type) { 94 var storageType = "".concat(type, "Storage"); 95 if (hasStorage(storageType)) return self[storageType];else { 96 if (false) {} 97 98 return noopStorage; 99 } 100} 101 102/***/ }), 103 104/***/ 1221: 105/***/ (function(module, exports, __webpack_require__) { 106 107"use strict"; 108 109 110Object.defineProperty(exports, "__esModule", { 111 value: true 112}); 113 114var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { 115 return typeof obj; 116} : function (obj) { 117 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 118}; 119 120exports.default = isImmutableDefault; 121 122function isImmutableDefault(value) { 123 return (typeof value === 'undefined' ? 'undefined' : _typeof(value)) !== 'object' || value === null || typeof value === 'undefined'; 124} 125 126/***/ }), 127 128/***/ 1222: 129/***/ (function(module, exports, __webpack_require__) { 130 131"use strict"; 132 133 134Object.defineProperty(exports, "__esModule", { 135 value: true 136}); 137exports.default = trackForMutations; 138 139function trackForMutations(isImmutable, ignore, obj) { 140 var trackedProperties = trackProperties(isImmutable, ignore, obj); 141 return { 142 detectMutations: function detectMutations() { 143 return _detectMutations(isImmutable, ignore, trackedProperties, obj); 144 } 145 }; 146} 147 148function trackProperties(isImmutable) { 149 var ignore = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 150 var obj = arguments[2]; 151 var path = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : []; 152 var tracked = { 153 value: obj 154 }; 155 156 if (!isImmutable(obj)) { 157 tracked.children = {}; 158 159 for (var key in obj) { 160 var childPath = path.concat(key); 161 162 if (ignore.length && ignore.indexOf(childPath.join('.')) !== -1) { 163 continue; 164 } 165 166 tracked.children[key] = trackProperties(isImmutable, ignore, obj[key], childPath); 167 } 168 } 169 170 return tracked; 171} 172 173function _detectMutations(isImmutable) { 174 var ignore = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 175 var trackedProperty = arguments[2]; 176 var obj = arguments[3]; 177 var sameParentRef = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
178 var path = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : []; 179 var prevObj = trackedProperty ? trackedProperty.value : undefined; 180 var sameRef = prevObj === obj; 181 182 if (sameParentRef && !sameRef && !Number.isNaN(obj)) { 183 return { 184 wasMutated: true, 185 path: path 186 }; 187 } 188 189 if (isImmutable(prevObj) || isImmutable(obj)) { 190 return { 191 wasMutated: false 192 }; 193 } // Gather all keys from prev (tracked) and after objs 194 195 196 var keysToDetect = {}; 197 Object.keys(trackedProperty.children).forEach(function (key) { 198 keysToDetect[key] = true; 199 }); 200 Object.keys(obj).forEach(function (key) { 201 keysToDetect[key] = true; 202 }); 203 var keys = Object.keys(keysToDetect); 204 205 for (var i = 0; i < keys.length; i++) { 206 var key = keys[i]; 207 var childPath = path.concat(key); 208 209 if (ignore.length && ignore.indexOf(childPath.join('.')) !== -1) { 210 continue; 211 } 212 213 var result = _detectMutations(isImmutable, ignore, trackedProperty.children[key], obj[key], sameRef, childPath); 214 215 if (result.wasMutated) { 216 return result; 217 } 218 } 219 220 return { 221 wasMutated: false 222 }; 223} 224 225/***/ }), 226 227/***/ 1223: 228/***/ (function(module, exports, __webpack_require__) { 229 230/* WEBPACK VAR INJECTION */(function(global) {!function (e, t) { 231 true ? t(exports) : undefined; 232}(this, function (e) { 233 "use strict"; 234 235 function t(e, t) { 236 e.super_ = t, e.prototype = Object.create(t.prototype, { 237 constructor: { 238 value: e, 239 enumerable: !1, 240 writable: !0, 241 configurable: !0 242 } 243 }); 244 } 245 246 function r(e, t) { 247 Object.defineProperty(this, "kind", { 248 value: e, 249 enumerable: !0 250 }), t && t.length && Object.defineProperty(this, "path", { 251 value: t, 252 enumerable: !0 253 }); 254 } 255 256 function n(e, t, r) { 257 n.super_.call(this, "E", e), Object.defineProperty(this, "lhs", { 258 value: t, 259 enumerable: !0 260 }), Object.defineProperty(this, "rhs", { 261 value: r, 262 enumerable: !0 263 }); 264 } 265 266 function o(e, t) { 267 o.super_.call(this, "N", e), Object.defineProperty(this, "rhs", { 268 value: t, 269 enumerable: !0 270 }); 271 } 272 273 function i(e, t) { 274 i.super_.call(this, "D", e), Object.defineProperty(this, "lhs", { 275 value: t, 276 enumerable: !0 277 }); 278 } 279 280 function a(e, t, r) { 281 a.super_.call(this, "A", e), Object.defineProperty(this, "index", { 282 value: t, 283 enumerable: !0 284 }), Object.defineProperty(this, "item", { 285 value: r, 286 enumerable: !0 287 }); 288 } 289 290 function f(e, t, r) { 291 var n = e.slice((r || t) + 1 || e.length); 292 return e.length = t < 0 ? e.length + t : t, e.push.apply(e, n), e; 293 } 294 295 function u(e) { 296 var t = "undefined" == typeof e ? "undefined" : N(e); 297 return "object" !== t ? t : e === Math ? "math" : null === e ? "null" : Array.isArray(e) ? "array" : "[object Date]" === Object.prototype.toString.call(e) ? "date" : "function" == typeof e.toString && /^\/.*\//.test(e.toString()) ? "regexp" : "object"; 298 } 299 300 function l(e, t, r, c, s, d, p) { 301 s = s || [], p = p || []; 302 var g = s.slice(0); 303 304 if ("undefined" != typeof d) { 305 if (c) { 306 if ("function" == typeof c && c(g, d)) return; 307 308 if ("object" === ("undefined" == typeof c ? "undefined" : N(c))) { 309 if (c.prefilter && c.prefilter(g, d)) return; 310 311 if (c.normalize) { 312 var h = c.normalize(g, d, e, t); 313 h && (e = h[0], t = h[1]); 314 } 315 } 316 } 317 318 g.push(d); 319 } 320 321 "regexp" === u(e) && "regexp" === u(t) && (e = e.toString(), t = t.toString()); 322 var y = "undefined" == typeof e ? "undefined" : N(e), 323 v = "undefined" == typeof t ? "undefined" : N(t), 324 b = "undefined" !== y || p && p[p.length - 1].lhs && p[p.length - 1].lhs.hasOwnProperty(d), 325 m = "undefined" !== v || p && p[p.length - 1].rhs && p[p.length - 1].rhs.hasOwnProperty(d); 326 if (!b && m) r(new o(g, t));else if (!m && b) r(new i(g, e));else if (u(e) !== u(t)) r(new n(g, e, t));else if ("date" === u(e) && e - t !== 0) r(new n(g, e, t));else if ("object" === y && null !== e && null !== t) { 327 if (p.filter(function (t) { 328 return t.lhs === e; 329 }).length) e !== t && r(new n(g, e, t));else { 330 if (p.push({ 331 lhs: e, 332 rhs: t 333 }), Array.isArray(e)) { 334 var w; 335 e.length; 336 337 for (w = 0; w < e.length; w++) { 338 w >= t.length ? r(new a(g, w, new i(void 0, e[w]))) : l(e[w], t[w], r, c, g, w, p); 339 } 340 341 for (; w < t.length;) { 342 r(new a(g, w, new o(void 0, t[w++]))); 343 } 344 } else { 345 var x = Object.keys(e), 346 S = Object.keys(t); 347 x.forEach(function (n, o) { 348 var i = S.indexOf(n); 349 i >= 0 ? (l(e[n], t[n], r, c, g, n, p), S = f(S, i)) : l(e[n], void 0, r, c, g, n, p); 350 }
350), S.forEach(function (e) { 351 l(void 0, t[e], r, c, g, e, p); 352 }); 353 } 354 355 p.length = p.length - 1; 356 } 357 } else e !== t && ("number" === y && isNaN(e) && isNaN(t) || r(new n(g, e, t))); 358 } 359 360 function c(e, t, r, n) { 361 return n = n || [], l(e, t, function (e) { 362 e && n.push(e); 363 }, r), n.length ? n : void 0; 364 } 365 366 function s(e, t, r) { 367 if (r.path && r.path.length) { 368 var n, 369 o = e[t], 370 i = r.path.length - 1; 371 372 for (n = 0; n < i; n++) { 373 o = o[r.path[n]]; 374 } 375 376 switch (r.kind) { 377 case "A": 378 s(o[r.path[n]], r.index, r.item); 379 break; 380 381 case "D": 382 delete o[r.path[n]]; 383 break; 384 385 case "E": 386 case "N": 387 o[r.path[n]] = r.rhs; 388 } 389 } else switch (r.kind) { 390 case "A": 391 s(e[t], r.index, r.item); 392 break; 393 394 case "D": 395 e = f(e, t); 396 break; 397 398 case "E": 399 case "N": 400 e[t] = r.rhs; 401 } 402 403 return e; 404 } 405 406 function d(e, t, r) { 407 if (e && t && r && r.kind) { 408 for (var n = e, o = -1, i = r.path ? r.path.length - 1 : 0; ++o < i;) { 409 "undefined" == typeof n[r.path[o]] && (n[r.path[o]] = "number" == typeof r.path[o] ? [] : {}), n = n[r.path[o]]; 410 } 411 412 switch (r.kind) { 413 case "A": 414 s(r.path ? n[r.path[o]] : n, r.index, r.item); 415 break; 416 417 case "D": 418 delete n[r.path[o]]; 419 break; 420 421 case "E": 422 case "N": 423 n[r.path[o]] = r.rhs; 424 } 425 } 426 } 427 428 function p(e, t, r) { 429 if (r.path && r.path.length) { 430 var n, 431 o = e[t], 432 i = r.path.length - 1; 433 434 for (n = 0; n < i; n++) { 435 o = o[r.path[n]]; 436 } 437 438 switch (r.kind) { 439 case "A": 440 p(o[r.path[n]], r.index, r.item); 441 break; 442 443 case "D": 444 o[r.path[n]] = r.lhs; 445 break; 446 447 case "E": 448 o[r.path[n]] = r.lhs; 449 break; 450 451 case "N": 452 delete o[r.path[n]]; 453 } 454 } else switch (r.kind) { 455 case "A": 456 p(e[t], r.index, r.item); 457 break; 458 459 case "D": 460 e[t] = r.lhs; 461 break; 462 463 case "E": 464 e[t] = r.lhs; 465 break; 466 467 case "N": 468 e = f(e, t); 469 } 470 471 return e; 472 } 473 474 function g(e, t, r) { 475 if (e && t && r && r.kind) { 476 var n, 477 o, 478 i = e; 479 480 for (o = r.path.length - 1, n = 0; n < o; n++) { 481 "undefined" == typeof i[r.path[n]] && (i[r.path[n]] = {}), i = i[r.path[n]]; 482 } 483 484 switch (r.kind) { 485 case "A": 486 p(i[r.path[n]], r.index, r.item); 487 break; 488 489 case "D": 490 i[r.path[n]] = r.lhs; 491 break; 492 493 case "E": 494 i[r.path[n]] = r.lhs; 495 break; 496 497 case "N": 498 delete i[r.path[n]]; 499 } 500 } 501 } 502 503 function h(e, t, r) { 504 if (e && t) { 505 var n = function n(_n) { 506 r && !r(e, t, _n) || d(e, t, _n); 507 }; 508 509 l(e, t, n); 510 } 511 } 512 513 function y(e) { 514 return "color: " + F[e].color + "; font-weight: bold"; 515 } 516 517 function v(e) { 518 var t = e.kind, 519 r = e.path, 520 n = e.lhs, 521 o = e.rhs, 522 i = e.index, 523 a = e.item; 524 525 switch (t) { 526 case "E": 527 return [r.join("."), n, "â", o]; 528 529 case "N": 530 return [r.join("."), o]; 531 532 case "D": 533 return [r.join(".")]; 534 535 case "A": 536 return [r.join(".") + "[" + i + "]", a]; 537 538 default: 539 return []; 540 } 541 } 542 543 function b(e, t, r, n) { 544 var o = c(e, t); 545 546 try { 547 n ? r.groupCollapsed("diff") : r.group("diff"); 548 } catch (e) { 549 r.log("diff"); 550 } 551 552 o ? o.forEach(function (e) { 553 var t = e.kind, 554 n = v(e); 555 r.log.apply(r, ["%c " + F[t].text, y(t)].concat(P(n))); 556 }) : r.log("ââ no diff ââ"); 557 558 try { 559 r.groupEnd(); 560 } catch (e) { 561 r.log("ââ diff end ââ "); 562 } 563 } 564 565 function m(e, t, r, n) { 566 switch ("undefined" == typeof e ? "undefined" : N(e)) { 567 case "object": 568 return "function" == typeof e[n] ? e[n].apply(e, P(r)) : e[n]; 569 570 case "function": 571 return e(t); 572 573 default: 574 return e; 575 } 576 } 577 578 function w(e) { 579 var t = e.timestamp, 580 r = e.duration; 581 return function (e, n, o) { 582 var i = ["action"]; 583 return i.push("%c" + String(e.type)), t && i.push("%c@ " + n), r && i.push("%c(in " + o.toFixed(2) + " ms)"), i.join(" "); 584 }; 585 } 586 587 function x(e, t) { 588 var r = t.logger, 589 n = t.actionTransformer, 590 o = t.titleFormatter, 591 i = void 0 === o ? w(t) : o, 592 a = t.collapsed, 593 f = t.colors, 594 u = t.level, 595 l = t.diff, 596 c = "undefined" == typeof t.titleFormatter; 597 e.forEach(function (o, s) { 598 var d = o.started, 599 p = o.startedTime, 600 g = o.action, 601 h = o.prevState, 602 y = o.error, 603 v = o.took, 604 w = o.nextState, 605 x = e[s + 1]; 606 x && (w = x.prevState, v = x.started - d); 607 var S = n(g), 608 k = "function" == typeof a ? a(function () { 609 return w; 610 }, g, o) : a, 611 j = D(p), 612 E = f.title ? "color: " + f.title(S) + ";" : "", 613 A = ["color: gray; font-weight: lighter;"]; 614 A.push(E), t.timestamp && A.push("color: gray; font-weight: lighter;"), t.duration && A.push("color: gray; font-weight: lighter;"); 615 var O = i(S, j, v); 616
617 try { 618 k ? f.title && c ? r.groupCollapsed.apply(r, ["%c " + O].concat(A)) : r.groupCollapsed(O) : f.title && c ? r.group.apply(r, ["%c " + O].concat(A)) : r.group(O); 619 } catch (e) { 620 r.log(O); 621 } 622 623 var N = m(u, S, [h], "prevState"), 624 P = m(u, S, [S], "action"), 625 C = m(u, S, [y, h], "error"), 626 F = m(u, S, [w], "nextState"); 627 if (N) if (f.prevState) { 628 var L = "color: " + f.prevState(h) + "; font-weight: bold"; 629 r[N]("%c prev state", L, h); 630 } else r[N]("prev state", h); 631 if (P) if (f.action) { 632 var T = "color: " + f.action(S) + "; font-weight: bold"; 633 r[P]("%c action ", T, S); 634 } else r[P]("action ", S); 635 if (y && C) if (f.error) { 636 var M = "color: " + f.error(y, h) + "; font-weight: bold;"; 637 r[C]("%c error ", M, y); 638 } else r[C]("error ", y); 639 if (F) if (f.nextState) { 640 var _ = "color: " + f.nextState(w) + "; font-weight: bold"; 641 642 r[F]("%c next state", _, w); 643 } else r[F]("next state", w); 644 l && b(h, w, r, k); 645 646 try { 647 r.groupEnd(); 648 } catch (e) { 649 r.log("ââ log end ââ"); 650 } 651 }); 652 } 653 654 function S() { 655 var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, 656 t = Object.assign({}, L, e), 657 r = t.logger, 658 n = t.stateTransformer, 659 o = t.errorTransformer, 660 i = t.predicate, 661 a = t.logErrors, 662 f = t.diffPredicate; 663 if ("undefined" == typeof r) return function () { 664 return function (e) { 665 return function (t) { 666 return e(t); 667 }; 668 }; 669 }; 670 if (e.getState && e.dispatch) return console.error("[redux-logger] redux-logger not installed. Make sure to pass logger instance as middleware:\n// Logger with default options\nimport { logger } from 'redux-logger'\nconst store = createStore(\n reducer,\n applyMiddleware(logger)\n)\n// Or you can create your own logger with custom options http://bit.ly/redux-logger-options\nimport createLogger from 'redux-logger'\nconst logger = createLogger({\n // ...options\n});\nconst store = createStore(\n reducer,\n applyMiddleware(logger)\n)\n"), function () { 671 return function (e) { 672 return function (t) { 673 return e(t); 674 }; 675 }; 676 }; 677 var u = []; 678 return function (e) { 679 var r = e.getState; 680 return function (e) { 681 return function (l) { 682 if ("function" == typeof i && !i(r, l)) return e(l); 683 var c = {}; 684 u.push(c), c.started = O.now(), c.startedTime = new Date(), c.prevState = n(r()), c.action = l; 685 var s = void 0; 686 if (a) try { 687 s = e(l); 688 } catch (e) { 689 c.error = o(e); 690 } else s = e(l); 691 c.took = O.now() - c.started, c.nextState = n(r()); 692 var d = t.diff && "function" == typeof f ? f(r, l) : t.diff; 693 if (x(u, Object.assign({}, t, { 694 diff: d 695 })), u.length = 0, c.error) throw c.error; 696 return s; 697 }; 698 }; 699 }; 700 } 701 702 var k, 703 j, 704 E = function E(e, t) { 705 return new Array(t + 1).join(e); 706 }, 707 A = function A(e, t) { 708 return E("0", t - e.toString().length) + e; 709 }, 710 D = function D(e) { 711 return A(e.getHours(), 2) + ":" + A(e.getMinutes(), 2) + ":" + A(e.getSeconds(), 2) + "." + A(e.getMilliseconds(), 3); 712 }, 713 O = "undefined" != typeof performance && null !== performance && "function" == typeof performance.now ? performance : Date, 714 N = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (e) { 715 return typeof e; 716 } : function (e) { 717 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e; 718 }, 719 P = function P(e) { 720 if (Array.isArray(e)) { 721 for (var t = 0, r = Array(e.length); t < e.length; t++) { 722 r[t] = e[t]; 723 } 724 725 return r; 726 } 727 728 return Array.from(e); 729 }, 730 C = []; 731 732 k = "object" === ("undefined" == typeof global ? "undefined" : N(global)) && global ? global : "undefined" != typeof window ? window : {}, j = k.DeepDiff, j && C.push(function () { 733 "undefined" != typeof j && k.DeepDiff === c && (k.DeepDiff = j, j = void 0); 734 }), t(n, r), t(o, r), t(i, r), t(a, r), Object.defineProperties(c, { 735 diff: { 736 value: c, 737 enumerable: !0 738 }, 739 observableDiff: { 740 value: l, 741 enumerable: !0 742 }, 743 applyDiff: { 744 value: h, 745 enumerable: !0 746 }, 747 applyChange: { 748 value: d, 749 enumerable: !0 750 }, 751 revertChange: { 752 value: g, 753 enumerable: !0 754 }, 755 isConflict: { 756 value: function value() { 757 return "undefined" != typeof j; 758 }, 759 enumerable: !0 760 }, 761 noConflict: { 762 value: function value() { 763 return C && (C.forEach(function (e) { 764 e(); 765 }), C = null), c; 766 }, 767 enumerable: !0 768 } 769 }); 770 771 var F = { 772 E: { 773 color: "#2196F3", 774 text: "CHANGED:" 775 }, 776 N: { 777 color: "#4CAF50", 778 text: "ADDED:" 779 }, 780 D: { 781 color: "#F44336", 782 text: "DELETED:" 783 }, 784 A: { 785 color: "#2196F3", 786 text: "ARRAY:" 787 } 788 }, 789 L = { 790 level: "log", 791 logger: console, 792 logErrors: !0, 793 collapsed: void 0, 794 predicate: void 0, 795 duration: !1, 796 timestamp: !0, 797 stateTransformer: function stateTransformer(e) { 798 return e; 799 }, 800 actionTransformer: function actionTransformer(e) { 801 return e; 802 }, 803 errorTransformer: function errorTransformer(e) { 804 return e; 805 }, 806 colors: { 807 title: function title() { 808 return "inherit"; 809 }, 810 prevState: function prevState() { 811 return "#9E9E9E"; 812 }, 813 action: function action() { 814 return "#03A9F4"; 815 }, 816 nextState: function nextState() { 817 return "#4CAF50"; 818 }, 819 error: function error() { 820 return "#F20404"; 821 } 822 }, 823 diff: !1, 824 diffPredicate: void 0, 825 transformer: void 0 826 }, 827 T = function T() { 828 var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, 829 t = e.dispatch, 830 r = e.getState; 831 return "function" == typeof t || "function" == typeof r ? S()({ 832 dispatch: t, 833 getState: r 834 }) : void console.error("\n[redux-logger v3] BREAKING CHANGE\n[redux-logger v3] Since 3.0.0 redux-logger exports by default logger with default settings.\n[redux-logger v3] Change\n[redux-logger v3] import createLogger from 'redux-logger'\n[redux-logger v3] to\n[redux-logger v3] import { createLogger } from 'redux-logger'\n"); 835 }; 836 837 e.defaults = L, e.createLogger = S, e.logger = T, e.default = T, Object.defineProperty(e, "__esModule", { 838 value: !0 839 }); 840}); 841/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(108))) 842 843/***/ }), 844 845/***/ 148: 846/***/ (function(module, __webpack_exports__, __webpack_require__) { 847 848"use strict"; 849__webpack_require__.r(__webpack_exports__); 850/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__DO_NOT_USE__ActionTypes", function() { return ActionTypes; }); 851/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "applyMiddleware", function() { return applyMiddleware; }); 852/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bindActionCreators", function() { return bindActionCreators; }); 853/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "combineReducers", function() { return combineReducers; }); 854/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "compose", function() { return compose; }); 855/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createStore", function() { return createStore; }); 856/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "legacy_createStore", function() { return legacy_createStore; }); 857/* harmony import */ var _babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(416); 858 859/** 860 * Adapted from React: https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessage.js 861 * 862 * Do not require this module directly! Use normal throw error calls. These messages will be replaced with error codes 863 * during build. 864 * @param {number} code 865 */ 866 867function formatProdErrorMessage(code) { 868 return "Minified Redux error #" + code + "; visit https://redux.js.org/Errors?code=" + code + " for the full message or " + 'use the non-minified dev environment for full errors. '; 869}
vendor: 4,466 bytes, lines 869-1021
869 // Inlined version of the `symbol-observable` polyfill 870 871 872var $$observable = function () { 873 return typeof Symbol === 'function' && Symbol.observable || '@@observable'; 874}(); 875/** 876 * These are private action types reserved by Redux. 877 * For any unknown actions, you must return the current state. 878 * If the current state is undefined, you must return the initial state. 879 * Do not reference these action types directly in your code. 880 */ 881 882 883var randomString = function randomString() { 884 return Math.random().toString(36).substring(7).split('').join('.'); 885}; 886 887var ActionTypes = { 888 INIT: "@@redux/INIT" + randomString(), 889 REPLACE: "@@redux/REPLACE" + randomString(), 890 PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() { 891 return "@@redux/PROBE_UNKNOWN_ACTION" + randomString(); 892 } 893}; 894/** 895 * @param {any} obj The object to inspect. 896 * @returns {boolean} True if the argument appears to be a plain object. 897 */ 898 899function isPlainObject(obj) { 900 if (typeof obj !== 'object' || obj === null) return false; 901 var proto = obj; 902 903 while (Object.getPrototypeOf(proto) !== null) { 904 proto = Object.getPrototypeOf(proto); 905 } 906 907 return Object.getPrototypeOf(obj) === proto; 908} // Inlined / shortened version of `kindOf` from https://github.com/jonschlinkert/kind-of 909 910 911function miniKindOf(val) { 912 if (val === void 0) return 'undefined'; 913 if (val === null) return 'null'; 914 var type = typeof val; 915 916 switch (type) { 917 case 'boolean': 918 case 'string': 919 case 'number': 920 case 'symbol': 921 case 'function': 922 { 923 return type; 924 } 925 } 926 927 if (Array.isArray(val)) return 'array'; 928 if (isDate(val)) return 'date'; 929 if (isError(val)) return 'error'; 930 var constructorName = ctorName(val); 931 932 switch (constructorName) { 933 case 'Symbol': 934 case 'Promise': 935 case 'WeakMap': 936 case 'WeakSet': 937 case 'Map': 938 case 'Set': 939 return constructorName; 940 } // other 941 942 943 return type.slice(8, -1).toLowerCase().replace(/\s/g, ''); 944} 945 946function ctorName(val) { 947 return typeof val.constructor === 'function' ? val.constructor.name : null; 948} 949 950function isError(val) { 951 return val instanceof Error || typeof val.message === 'string' && val.constructor && typeof val.constructor.stackTraceLimit === 'number'; 952} 953 954function isDate(val) { 955 if (val instanceof Date) return true; 956 return typeof val.toDateString === 'function' && typeof val.getDate === 'function' && typeof val.setDate === 'function'; 957} 958 959function kindOf(val) { 960 var typeOfVal = typeof val; 961 962 if (false) {} 963 964 return typeOfVal; 965} 966/** 967 * @deprecated 968 * 969 * **We recommend using the `configureStore` method 970 * of the `@reduxjs/toolkit` package**, which replaces `createStore`. 971 * 972 * Redux Toolkit is our recommended approach for writing Redux logic today, 973 * including store setup, reducers, data fetching, and more. 974 * 975 * **For more details, please read this Redux docs page:** 976 * **https://redux.js.org/introduction/why-rtk-is-redux-today** 977 * 978 * `configureStore` from Redux Toolkit is an improved version of `createStore` that 979 * simplifies setup and helps avoid common bugs. 980 * 981 * You should not be using the `redux` core package by itself today, except for learning purposes. 982 * The `createStore` method from the core `redux` package will not be removed, but we encourage 983 * all users to migrate to using Redux Toolkit for all Redux code. 984 * 985 * If you want to use `createStore` without this visual deprecation warning, use 986 * the `legacy_createStore` import instead: 987 * 988 * `import { legacy_createStore as createStore} from 'redux'` 989 * 990 */ 991 992 993function createStore(reducer, preloadedState, enhancer) { 994 var _ref2; 995 996 if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') { 997 throw new Error( true ? formatProdErrorMessage(0) : undefined); 998 } 999 1000 if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') { 1001 enhancer = preloadedState; 1002 preloadedState = undefined; 1003 } 1004 1005 if (typeof enhancer !== 'undefined') { 1006 if (typeof enhancer !== 'function') { 1007 throw new Error( true ? formatProdErrorMessage(1) : undefined); 1008 } 1009 1010 return enhancer(createStore)(reducer, preloadedState); 1011 } 1012 1013 if (typeof reducer !== 'function') { 1014 throw new Error( true ? formatProdErrorMessage(2) : undefined); 1015 } 1016 1017 var currentReducer = reducer; 1018 var currentState = preloadedState; 1019 var currentListeners = []; 1020 var nextListeners = currentListeners; 1021 var isDispatching = false;
1022 /** 1023 * This makes a shallow copy of currentListeners so we can use 1024 * nextListeners as a temporary list while dispatching. 1025 * 1026 * This prevents any bugs around consumers calling 1027 * subscribe/unsubscribe in the middle of a dispatch. 1028 */ 1029 1030 function ensureCanMutateNextListeners() { 1031 if (nextListeners === currentListeners) { 1032 nextListeners = currentListeners.slice(); 1033 } 1034 } 1035 /** 1036 * Reads the state tree managed by the store. 1037 * 1038 * @returns {any} The current state tree of your application. 1039 */ 1040 1041 1042 function getState() { 1043 if (isDispatching) { 1044 throw new Error( true ? formatProdErrorMessage(3) : undefined); 1045 } 1046 1047 return currentState; 1048 } 1049 /** 1050 * Adds a change listener. It will be called any time an action is dispatched, 1051 * and some part of the state tree may potentially have changed. You may then 1052 * call `getState()` to read the current state tree inside the callback. 1053 * 1054 * You may call `dispatch()` from a change listener, with the following 1055 * caveats: 1056 * 1057 * 1. The subscriptions are snapshotted just before every `dispatch()` call. 1058 * If you subscribe or unsubscribe while the listeners are being invoked, this 1059 * will not have any effect on the `dispatch()` that is currently in progress. 1060 * However, the next `dispatch()` call, whether nested or not, will use a more 1061 * recent snapshot of the subscription list. 1062 * 1063 * 2. The listener should not expect to see all state changes, as the state 1064 * might have been updated multiple times during a nested `dispatch()` before 1065 * the listener is called. It is, however, guaranteed that all subscribers 1066 * registered before the `dispatch()` started will be called with the latest 1067 * state by the time it exits. 1068 * 1069 * @param {Function} listener A callback to be invoked on every dispatch. 1070 * @returns {Function} A function to remove this change listener. 1071 */ 1072 1073 1074 function subscribe(listener) { 1075 if (typeof listener !== 'function') { 1076 throw new Error( true ? formatProdErrorMessage(4) : undefined); 1077 } 1078 1079 if (isDispatching) { 1080 throw new Error( true ? formatProdErrorMessage(5) : undefined); 1081 } 1082 1083 var isSubscribed = true; 1084 ensureCanMutateNextListeners(); 1085 nextListeners.push(listener); 1086 return function unsubscribe() { 1087 if (!isSubscribed) { 1088 return; 1089 } 1090 1091 if (isDispatching) { 1092 throw new Error( true ? formatProdErrorMessage(6) : undefined); 1093 } 1094 1095 isSubscribed = false; 1096 ensureCanMutateNextListeners(); 1097 var index = nextListeners.indexOf(listener); 1098 nextListeners.splice(index, 1); 1099 currentListeners = null; 1100 }; 1101 } 1102 /** 1103 * Dispatches an action. It is the only way to trigger a state change. 1104 * 1105 * The `reducer` function, used to create the store, will be called with the 1106 * current state tree and the given `action`. Its return value will 1107 * be considered the **next** state of the tree, and the change listeners 1108 * will be notified. 1109 * 1110 * The base implementation only supports plain object actions. If you want to 1111 * dispatch a Promise, an Observable, a thunk, or something else, you need to 1112 * wrap your store creating function into the corresponding middleware. For 1113 * example, see the documentation for the `redux-thunk` package. Even the 1114 * middleware will eventually dispatch plain object actions using this method. 1115 * 1116 * @param {Object} action A plain object representing âwhat changedâ. It is 1117 * a good idea to keep actions serializable so you can record and replay user 1118 * sessions, or use the time travelling `redux-devtools`. An action must have 1119 * a `type` property which may not be `undefined`. It is a good idea to use 1120 * string constants for action types. 1121 * 1122 * @returns {Object} For convenience, the same action object you dispatched. 1123 * 1124 * Note that, if you use a custom middleware, it may wrap `dispatch()` to 1125 * return something else (for example, a Promise you can await). 1126 */ 1127 1128 1129 function dispatch(action) { 1130 if (!isPlainObject(action)) { 1131 throw new Error( true ? formatProdErrorMessage(7) : undefined); 1132 } 1133 1134 if (typeof action.type === 'undefined') { 1135 throw new Error( true ? formatProdErrorMessage(8) : undefined); 1136 } 1137 1138 if (isDispatching) { 1139 throw new Error( true ? formatProdErrorMessage(9) : undefined); 1140 } 1141 1142 try { 1143 isDispatching = true; 1144 currentState = currentReducer(currentState, action); 1145 } finally { 1146 isDispatching = false;
vendor: 3,158 bytes, lines 1147-1248
1147 } 1148 1149 var listeners = currentListeners = nextListeners; 1150 1151 for (var i = 0; i < listeners.length; i++) { 1152 var listener = listeners[i]; 1153 listener(); 1154 } 1155 1156 return action; 1157 } 1158 /** 1159 * Replaces the reducer currently used by the store to calculate the state. 1160 * 1161 * You might need this if your app implements code splitting and you want to 1162 * load some of the reducers dynamically. You might also need this if you 1163 * implement a hot reloading mechanism for Redux. 1164 * 1165 * @param {Function} nextReducer The reducer for the store to use instead. 1166 * @returns {void} 1167 */ 1168 1169 1170 function replaceReducer(nextReducer) { 1171 if (typeof nextReducer !== 'function') { 1172 throw new Error( true ? formatProdErrorMessage(10) : undefined); 1173 } 1174 1175 currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT. 1176 // Any reducers that existed in both the new and old rootReducer 1177 // will receive the previous state. This effectively populates 1178 // the new state tree with any relevant data from the old one. 1179 1180 dispatch({ 1181 type: ActionTypes.REPLACE 1182 }); 1183 } 1184 /** 1185 * Interoperability point for observable/reactive libraries. 1186 * @returns {observable} A minimal observable of state changes. 1187 * For more information, see the observable proposal: 1188 * https://github.com/tc39/proposal-observable 1189 */ 1190 1191 1192 function observable() { 1193 var _ref; 1194 1195 var outerSubscribe = subscribe; 1196 return _ref = { 1197 /** 1198 * The minimal observable subscription method. 1199 * @param {Object} observer Any object that can be used as an observer. 1200 * The observer object should have a `next` method. 1201 * @returns {subscription} An object with an `unsubscribe` method that can 1202 * be used to unsubscribe the observable from the store, and prevent further 1203 * emission of values from the observable. 1204 */ 1205 subscribe: function subscribe(observer) { 1206 if (typeof observer !== 'object' || observer === null) { 1207 throw new Error( true ? formatProdErrorMessage(11) : undefined); 1208 } 1209 1210 function observeState() { 1211 if (observer.next) { 1212 observer.next(getState()); 1213 } 1214 } 1215 1216 observeState(); 1217 var unsubscribe = outerSubscribe(observeState); 1218 return { 1219 unsubscribe: unsubscribe 1220 }; 1221 } 1222 }, _ref[$$observable] = function () { 1223 return this; 1224 }, _ref; 1225 } // When a store is created, an "INIT" action is dispatched so that every 1226 // reducer returns their initial state. This effectively populates 1227 // the initial state tree. 1228 1229 1230 dispatch({ 1231 type: ActionTypes.INIT 1232 }); 1233 return _ref2 = { 1234 dispatch: dispatch, 1235 subscribe: subscribe, 1236 getState: getState, 1237 replaceReducer: replaceReducer 1238 }, _ref2[$$observable] = observable, _ref2; 1239} 1240/** 1241 * Creates a Redux store that holds the state tree. 1242 * 1243 * **We recommend using `configureStore` from the 1244 * `@reduxjs/toolkit` package**, which replaces `createStore`: 1245 * **https://redux.js.org/introduction/why-rtk-is-redux-today** 1246 * 1247 * The only way to change the data in the store is to call `dispatch()` on it. 1248 *
1249 * There should only be a single store in your app. To specify how different 1250 * parts of the state tree respond to actions, you may combine several reducers 1251 * into a single reducer function by using `combineReducers`. 1252 * 1253 * @param {Function} reducer A function that returns the next state tree, given 1254 * the current state tree and the action to handle. 1255 * 1256 * @param {any} [preloadedState] The initial state. You may optionally specify it 1257 * to hydrate the state from the server in universal apps, or to restore a 1258 * previously serialized user session. 1259 * If you use `combineReducers` to produce the root reducer function, this must be 1260 * an object with the same shape as `combineReducers` keys. 1261 * 1262 * @param {Function} [enhancer] The store enhancer. You may optionally specify it 1263 * to enhance the store with third-party capabilities such as middleware, 1264 * time travel, persistence, etc. The only store enhancer that ships with Redux 1265 * is `applyMiddleware()`. 1266 * 1267 * @returns {Store} A Redux store that lets you read the state, dispatch actions 1268 * and subscribe to changes. 1269 */ 1270 1271 1272var legacy_createStore = createStore; 1273/** 1274 * Prints a warning in the console if it exists. 1275 * 1276 * @param {String} message The warning message. 1277 * @returns {void} 1278 */ 1279 1280function warning(message) { 1281 /* eslint-disable no-console */ 1282 if (typeof console !== 'undefined' && typeof console.error === 'function') { 1283 console.error(message); 1284 } 1285 /* eslint-enable no-console */ 1286 1287 1288 try { 1289 // This error was thrown as a convenience so that if you enable 1290 // "break on all exceptions" in your console, 1291 // it would pause the execution at this line. 1292 throw new Error(message); 1293 } catch (e) {} // eslint-disable-line no-empty 1294 1295} 1296 1297function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unex
vendor: 4,275 bytes, lines 1297-1422
1297pectedKeyCache) { 1298 var reducerKeys = Object.keys(reducers); 1299 var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer'; 1300 1301 if (reducerKeys.length === 0) { 1302 return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.'; 1303 } 1304 1305 if (!isPlainObject(inputState)) { 1306 return "The " + argumentName + " has unexpected type of \"" + kindOf(inputState) + "\". Expected argument to be an object with the following " + ("keys: \"" + reducerKeys.join('", "') + "\""); 1307 } 1308 1309 var unexpectedKeys = Object.keys(inputState).filter(function (key) { 1310 return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]; 1311 }); 1312 unexpectedKeys.forEach(function (key) { 1313 unexpectedKeyCache[key] = true; 1314 }); 1315 if (action && action.type === ActionTypes.REPLACE) return; 1316 1317 if (unexpectedKeys.length > 0) { 1318 return "Unexpected " + (unexpectedKeys.length > 1 ? 'keys' : 'key') + " " + ("\"" + unexpectedKeys.join('", "') + "\" found in " + argumentName + ". ") + "Expected to find one of the known reducer keys instead: " + ("\"" + reducerKeys.join('", "') + "\". Unexpected keys will be ignored."); 1319 } 1320} 1321 1322function assertReducerShape(reducers) { 1323 Object.keys(reducers).forEach(function (key) { 1324 var reducer = reducers[key]; 1325 var initialState = reducer(undefined, { 1326 type: ActionTypes.INIT 1327 }); 1328 1329 if (typeof initialState === 'undefined') { 1330 throw new Error( true ? formatProdErrorMessage(12) : undefined); 1331 } 1332 1333 if (typeof reducer(undefined, { 1334 type: ActionTypes.PROBE_UNKNOWN_ACTION() 1335 }) === 'undefined') { 1336 throw new Error( true ? formatProdErrorMessage(13) : undefined); 1337 } 1338 }); 1339} 1340/** 1341 * Turns an object whose values are different reducer functions, into a single 1342 * reducer function. It will call every child reducer, and gather their results 1343 * into a single state object, whose keys correspond to the keys of the passed 1344 * reducer functions. 1345 * 1346 * @param {Object} reducers An object whose values correspond to different 1347 * reducer functions that need to be combined into one. One handy way to obtain 1348 * it is to use ES6 `import * as reducers` syntax. The reducers may never return 1349 * undefined for any action. Instead, they should return their initial state 1350 * if the state passed to them was undefined, and the current state for any 1351 * unrecognized action. 1352 * 1353 * @returns {Function} A reducer function that invokes every reducer inside the 1354 * passed object, and builds a state object with the same shape. 1355 */ 1356 1357 1358function combineReducers(reducers) { 1359 var reducerKeys = Object.keys(reducers); 1360 var finalReducers = {}; 1361 1362 for (var i = 0; i < reducerKeys.length; i++) { 1363 var key = reducerKeys[i]; 1364 1365 if (false) {} 1366 1367 if (typeof reducers[key] === 'function') { 1368 finalReducers[key] = reducers[key]; 1369 } 1370 } 1371 1372 var finalReducerKeys = Object.keys(finalReducers); // This is used to make sure we don't warn about the same 1373 // keys multiple times. 1374 1375 var unexpectedKeyCache; 1376 1377 if (false) {} 1378 1379 var shapeAssertionError; 1380 1381 try { 1382 assertReducerShape(finalReducers); 1383 } catch (e) { 1384 shapeAssertionError = e; 1385 } 1386 1387 return function combination(state, action) { 1388 if (state === void 0) { 1389 state = {}; 1390 } 1391 1392 if (shapeAssertionError) { 1393 throw shapeAssertionError; 1394 } 1395 1396 if (false) { var warningMessage; } 1397 1398 var hasChanged = false; 1399 var nextState = {}; 1400 1401 for (var _i = 0; _i < finalReducerKeys.length; _i++) { 1402 var _key = finalReducerKeys[_i]; 1403 var reducer = finalReducers[_key]; 1404 var previousStateForKey = state[_key]; 1405 var nextStateForKey = reducer(previousStateForKey, action); 1406 1407 if (typeof nextStateForKey === 'undefined') { 1408 var actionType = action && action.type; 1409 throw new Error( true ? formatProdErrorMessage(14) : undefined); 1410 } 1411 1412 nextState[_key] = nextStateForKey; 1413 hasChanged = hasChanged || nextStateForKey !== previousStateForKey; 1414 } 1415 1416 hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length; 1417 return hasChanged ? nextState : state; 1418 }; 1419} 1420 1421function bindActionCreator(actionCreator, dispatch) { 1422 return function () {
1423 return dispatch(actionCreator.apply(this, arguments)); 1424 }; 1425} 1426/** 1427 * Turns an object whose values are action creators, into an object with the 1428 * same keys, but with every function wrapped into a `dispatch` call so they 1429 * may be invoked directly. This is just a convenience method, as you can call 1430 * `store.dispatch(MyActionCreators.doSomething())` yourself just fine. 1431 * 1432 * For convenience, you can also pass an action creator as the first argument, 1433 * and get a dispatch wrapped function in return. 1434 * 1435 * @param {Function|Object} actionCreators An object whose values are action 1436 * creator functions. One handy way to obtain it is to use ES6 `import * as` 1437 * syntax. You may also pass a single function. 1438 * 1439 * @param {Function} dispatch The `dispatch` function available on your Redux 1440 * store. 1441 * 1442 * @returns {Function|Object} The object mimicking the original object, but with 1443 * every action creator wrapped into the `dispatch` call. If you passed a 1444 * function as `actionCreators`, the return value will also be a single 1445 * function. 1446 */ 1447 1448 1449function bindActionCreators(actionCreators, dispatch) { 1450 if (typeof actionCreators === 'function') { 1451 return bindActionCreator(actionCreators, dispatch); 1452 } 1453 1454 if (typeof actionCreators !== 'object' || actionCreators === null) { 1455 throw new Error( true ? formatProdErrorMessage(16) : undefined); 1456 } 1457 1458 var boundActionCreators = {}; 1459 1460 for (var key in actionCreators) { 1461 var actionCreator = actionCreators[key]; 1462 1463 if (typeof actionCreator === 'function') { 1464 boundActionCreators[key] = bindActionCreator(actionCreator, dispatch); 1465 } 1466 } 1467 1468 return boundActionCreators; 1469} 1470/** 1471 * Composes single-argument functions from right to left. The rightmost 1472 * function can take multiple arguments as it provides the signature for 1473 * the resulting composite function. 1474 * 1475 * @param {...Function} funcs The functions to compose. 1476 * @returns {Function} A function obtained by composing the argument functions 1477 * from right to left. For example, compose(f, g, h) is identical to doing 1478 * (...args) => f(g(h(...args))). 1479 */ 1480 1481 1482function compose() { 1483 for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) { 1484 funcs[_key] = arguments[_key]; 1485 } 1486 1487 if (funcs.length === 0) { 1488 return function (arg) { 1489 return arg; 1490 }; 1491 } 1492 1493 if (funcs.length === 1) { 1494 return funcs[0]; 1495 } 1496 1497 return funcs.reduce(function (a, b) { 1498 return function () { 1499 return a(b.apply(void 0, arguments)); 1500 }; 1501 }); 1502} 1503/** 1504 * Creates a store enhancer that applies middleware to the dispatch method 1505 * of the Redux store. This is handy for a variety of tasks, such as expressing 1506 * asynchronous actions in a concise manner, or logging every action payload. 1507 * 1508 * See `redux-thunk` package as an example of the Redux middleware. 1509 * 1510 * Because middleware is potentially asynchronous, this should be the first 1511 * store enhancer in the composition chain. 1512 * 1513 * Note that each middleware will be given the `dispatch` and `getState` functions 1514 * as named arguments. 1515 * 1516 * @param {...Function} middlewares The middleware chain to be applied. 1517 * @returns {Function} A store enhancer applying the middleware. 1518 */ 1519 1520 1521function applyMiddleware() { 1522 for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) { 1523 middlewares[_key] = arguments[_key]; 1524 } 1525 1526 return function (createStore) { 1527 return function () { 1528 var store = createStore.apply(void 0, arguments); 1529 1530 var _dispatch = function dispatch() { 1531 throw new Error( true ? formatProdErrorMessage(15) : undefined); 1532 }; 1533 1534 var middlewareAPI = { 1535 getState: store.getState, 1536 dispatch: function dispatch() { 1537 return _dispatch.apply(void 0, arguments); 1538 } 1539 }; 1540 var chain = middlewares.map(function (middleware) { 1541 return middleware(middlewareAPI); 1542 }); 1543 _dispatch = compose.apply(void 0, chain)(store.dispatch); 1544 return Object(_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(Object(_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])({}, store), {}, { 1545 dispatch: _dispatch 1546 }); 1547 }; 1548 }; 1549} 1550/* 1551 * This is a dummy function to check if the function name has been altered by minification. 1552 * If the function has been minified and NODE_ENV !== 'production', warn the user. 1553 */ 1554 1555 1556function isCrushed() {} 1557 1558if (false) {} 1559 1560 1561 1562/***/ }), 1563 1564/***/ 351: 1565/***/ (function(module, __webpack_exports__, __webpack_require__) { 1566 1567"use strict"; 1568/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isPromise; }); 1569var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { 1570 return typeof obj; 1571} : function (obj) { 1572 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 1573}; 1574 1575function isPromise(value) { 1576 if (value !== null && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') { 1577 return value && typeof value.then === 'function'; 1578 } 1579 1580 return false;
1581} 1582 1583/***/ }), 1584 1585/***/ 417: 1586/***/ (function(module, __webpack_exports__, __webpack_require__) { 1587 1588"use strict"; 1589 1590// CONCATENATED MODULE: ./node_modules/redux-persist/es/constants.js 1591var KEY_PREFIX = 'persist:'; 1592var FLUSH = 'persist/FLUSH'; 1593var REHYDRATE = 'persist/REHYDRATE'; 1594var PAUSE = 'persist/PAUSE'; 1595var PERSIST = 'persist/PERSIST'; 1596var PURGE = 'persist/PURGE'; 1597var REGISTER = 'persist/REGISTER'; 1598var DEFAULT_VERSION = -1; 1599// CONCATENATED MODULE: ./node_modules/redux-persist/es/stateReconciler/autoMergeLevel1.js 1600function _typeof(obj) { 1601 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 1602 _typeof = function _typeof(obj) { 1603 return typeof obj; 1604 }; 1605 } else { 1606 _typeof = function _typeof(obj) { 1607 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 1608 }; 1609 } 1610 1611 return _typeof(obj); 1612} 1613 1614function ownKeys(object, enumerableOnly) { 1615 var keys = Object.keys(object); 1616 1617 if (Object.getOwnPropertySymbols) { 1618 var symbols = Object.getOwnPropertySymbols(object); 1619 if (enumerableOnly) symbols = symbols.filter(function (sym) { 1620 return Object.getOwnPropertyDescriptor(object, sym).enumerable; 1621 }); 1622 keys.push.apply(keys, symbols); 1623 } 1624 1625 return keys; 1626} 1627 1628function _objectSpread(target) { 1629 for (var i = 1; i < arguments.length; i++) { 1630 var source = arguments[i] != null ? arguments[i] : {}; 1631 1632 if (i % 2) { 1633 ownKeys(source, true).forEach(function (key) { 1634 _defineProperty(target, key, source[key]); 1635 }); 1636 } else if (Object.getOwnPropertyDescriptors) { 1637 Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); 1638 } else { 1639 ownKeys(source).forEach(function (key) { 1640 Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); 1641 }); 1642 } 1643 } 1644 1645 return target; 1646} 1647 1648function _defineProperty(obj, key, value) { 1649 if (key in obj) { 1650 Object.defineProperty(obj, key, { 1651 value: value, 1652 enumerable: true, 1653 configurable: true, 1654 writable: true 1655 }); 1656 } else { 1657 obj[key] = value; 1658 } 1659 1660 return obj; 1661} 1662/* 1663 autoMergeLevel1: 1664 - merges 1 level of substate 1665 - skips substate if already modified 1666*/ 1667 1668 1669function autoMergeLevel1(inboundState, originalState, reducedState, _ref) { 1670 var debug = _ref.debug; 1671 1672 var newState = _objectSpread({}, reducedState); // only rehydrate if inboundState exists and is an object 1673 1674 1675 if (inboundState && _typeof(inboundState) === 'object') { 1676 Object.keys(inboundState).forEach(function (key) { 1677 // ignore _persist data 1678 if (key === '_persist') return; // if reducer modifies substate, skip auto rehydration 1679 1680 if (originalState[key] !== reducedState[key]) { 1681 if (false) {} 1682 return; 1683 } // otherwise hard set the new value 1684 1685 1686 newState[key] = inboundState[key]; 1687 }); 1688 } 1689 1690 if (false) {} 1691 return newState; 1692} 1693// CONCATENATED MODULE: ./node_modules/redux-persist/es/createPersistoid.js 1694 // @TODO remove once flow < 0.63 support is no longer required. 1695 1696function createPersistoid(config) { 1697 // defaults 1698 var blacklist = config.blacklist || null; 1699 var whitelist = config.whitelist || null; 1700 var transforms = config.transforms || []; 1701 var throttle = config.throttle || 0; 1702 var storageKey = "".concat(config.keyPrefix !== undefined ? config.keyPrefix : KEY_PREFIX).concat(config.key); 1703 var storage = config.storage; 1704 var serialize; 1705 1706 if (config.serialize === false) { 1707 serialize = function serialize(x) { 1708 return x; 1709 }; 1710 } else if (typeof config.serialize === 'function') { 1711 serialize = config.serialize; 1712 } else { 1713 serialize = defaultSerialize; 1714 } 1715 1716 var writeFailHandler = config.writeFailHandler || null; // initialize stateful values 1717 1718 var lastState = {}; 1719 var stagedState = {}; 1720 var keysToProcess = []; 1721 var timeIterator = null; 1722 var writePromise = null; 1723 1724 var update = function update(state) { 1725 // add any changed keys to the queue 1726 Object.keys(state).forEach(function (key) { 1727 if (!passWhitelistBlacklist(key)) return; // is keyspace ignored? noop 1728 1729 if (lastState[key] === state[key]) return; // value unchanged? noop 1730 1731 if (keysToProcess.indexOf(key) !== -1) return; // is key already queued? noop 1732 1733 keysToProcess.push(key); // add key to queue 1734 }); //if any key is missing in the new state which was present in the lastState, 1735 //add it for processing too 1736 1737 Object.keys(lastState).forEach(function (key) { 1738 if (state[key] === undefined && passWhitelistBlacklist(key
1738) && keysToProcess.indexOf(key) === -1 && lastState[key] !== undefined) { 1739 keysToProcess.push(key); 1740 } 1741 }); // start the time iterator if not running (read: throttle) 1742 1743 if (timeIterator === null) { 1744 timeIterator = setInterval(processNextKey, throttle); 1745 } 1746 1747 lastState = state; 1748 }; 1749 1750 function processNextKey() { 1751 if (keysToProcess.length === 0) { 1752 if (timeIterator) clearInterval(timeIterator); 1753 timeIterator = null; 1754 return; 1755 } 1756 1757 var key = keysToProcess.shift(); 1758 var endState = transforms.reduce(function (subState, transformer) { 1759 return transformer.in(subState, key, lastState); 1760 }, lastState[key]); 1761 1762 if (endState !== undefined) { 1763 try { 1764 stagedState[key] = serialize(endState); 1765 } catch (err) { 1766 console.error('redux-persist/createPersistoid: error serializing state', err); 1767 } 1768 } else { 1769 //if the endState is undefined, no need to persist the existing serialized content 1770 delete stagedState[key]; 1771 } 1772 1773 if (keysToProcess.length === 0) { 1774 writeStagedState(); 1775 } 1776 } 1777 1778 function writeStagedState() { 1779 // cleanup any removed keys just before write. 1780 Object.keys(stagedState).forEach(function (key) { 1781 if (lastState[key] === undefined) { 1782 delete stagedState[key]; 1783 } 1784 }); 1785 writePromise = storage.setItem(storageKey, serialize(stagedState)).catch(onWriteFail); 1786 } 1787 1788 function passWhitelistBlacklist(key) { 1789 if (whitelist && whitelist.indexOf(key) === -1 && key !== '_persist') return false; 1790 if (blacklist && blacklist.indexOf(key) !== -1) return false; 1791 return true; 1792 } 1793 1794 function onWriteFail(err) { 1795 // @TODO add fail handlers (typically storage full) 1796 if (writeFailHandler) writeFailHandler(err); 1797 1798 if (err && "production" !== 'production') { 1799 console.error('Error storing data', err); 1800 } 1801 } 1802 1803 var flush = function flush() { 1804 while (keysToProcess.length !== 0) { 1805 processNextKey(); 1806 } 1807 1808 return writePromise || Promise.resolve(); 1809 }; // return `persistoid` 1810 1811 1812 return { 1813 update: update, 1814 flush: flush 1815 }; 1816} // @NOTE in the future this may be exposed via config 1817 1818function defaultSerialize(data) { 1819 return JSON.stringify(data); 1820} 1821// CONCATENATED MODULE: ./node_modules/redux-persist/es/getStoredState.js 1822 1823function getStoredState_getStoredState(config) { 1824 var transforms = config.transforms || []; 1825 var storageKey = "".concat(config.keyPrefix !== undefined ? config.keyPrefix : KEY_PREFIX).concat(config.key); 1826 var storage = config.storage; 1827 var debug = config.debug; 1828 var deserialize; 1829 1830 if (config.deserialize === false) { 1831 deserialize = function deserialize(x) { 1832 return x; 1833 }; 1834 } else if (typeof config.deserialize === 'function') { 1835 deserialize = config.deserialize; 1836 } else { 1837 deserialize = defaultDeserialize; 1838 } 1839 1840 return storage.getItem(storageKey).then(function (serialized) { 1841 if (!serialized) return undefined;else { 1842 try { 1843 var state = {}; 1844 var rawState = deserialize(serialized); 1845 Object.keys(rawState).forEach(function (key) { 1846 state[key] = transforms.reduceRight(function (subState, transformer) { 1847 return transformer.out(subState, key, rawState); 1848 }, deserialize(rawState[key])); 1849 }); 1850 return state; 1851 } catch (err) { 1852 if (false) {} 1853 throw err; 1854 } 1855 } 1856 }); 1857} 1858 1859function defaultDeserialize(serial) { 1860 return JSON.parse(serial); 1861} 1862// CONCATENATED MODULE: ./node_modules/redux-persist/es/purgeStoredState.js 1863 1864function purgeStoredState(config) { 1865 var storage = config.storage; 1866 var storageKey = "".concat(config.keyPrefix !== undefined ? config.keyPrefix : KEY_PREFIX).concat(config.key); 1867 return storage.removeItem(storageKey, warnIfRemoveError); 1868} 1869 1870function warnIfRemoveError(err) { 1871 if (err && "production" !== 'production') { 1872 console.error('redux-persist/purgeStoredState: Error purging data stored state', err); 1873 } 1874} 1875// CONCATENATED MODULE: ./node_modules/redux-persist/es/persistReducer.js 1876function persistReducer_ownKeys(object, enumerableOnly) { 1877 var keys = Object.keys(object); 1878 1879 if (Object.getOwnPropertySymbols) { 1880 var symbols = Object.getOwnPropertySymbols(object); 1881 if (enumerableOnly) symbols = symbols.filter(function (sym) { 1882 return Object.getOwnPropertyDescriptor(object, sym).enumerable; 1883 }); 1884 keys.push.apply(keys, symbols); 1885 } 1886 1887 return keys; 1888} 1889 1890function persistReducer_objectSpread(target) { 1891 for (var i = 1; i < arguments.length; i++) { 1892 var source = arguments[i] != null ? arguments[i] : {}; 1893 1894 if (i % 2) { 1895 persistReducer_ownKeys(source, true).forEach(function (key) { 1896 persistReducer_defineProperty(target, key, source[key]); 1897 }); 1898 } else if (Object.getOwnPropertyDescriptors) { 1899 Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); 1900 } else { 1901 persistReducer_ownKeys(source).forEach(function (key) {
1902 Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); 1903 }); 1904 } 1905 } 1906 1907 return target; 1908} 1909 1910function persistReducer_defineProperty(obj, key, value) { 1911 if (key in obj) { 1912 Object.defineProperty(obj, key, { 1913 value: value, 1914 enumerable: true, 1915 configurable: true, 1916 writable: true 1917 }); 1918 } else { 1919 obj[key] = value; 1920 } 1921 1922 return obj; 1923} 1924 1925function _objectWithoutProperties(source, excluded) { 1926 if (source == null) return {}; 1927 1928 var target = _objectWithoutPropertiesLoose(source, excluded); 1929 1930 var key, i; 1931 1932 if (Object.getOwnPropertySymbols) { 1933 var sourceSymbolKeys = Object.getOwnPropertySymbols(source); 1934 1935 for (i = 0; i < sourceSymbolKeys.length; i++) { 1936 key = sourceSymbolKeys[i]; 1937 if (excluded.indexOf(key) >= 0) continue; 1938 if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; 1939 target[key] = source[key]; 1940 } 1941 } 1942 1943 return target; 1944} 1945 1946function _objectWithoutPropertiesLoose(source, excluded) { 1947 if (source == null) return {}; 1948 var target = {}; 1949 var sourceKeys = Object.keys(source); 1950 var key, i; 1951 1952 for (i = 0; i < sourceKeys.length; i++) { 1953 key = sourceKeys[i]; 1954 if (excluded.indexOf(key) >= 0) continue; 1955 target[key] = source[key]; 1956 } 1957 1958 return target; 1959} 1960 1961 1962 1963 1964 1965 1966var DEFAULT_TIMEOUT = 5000; 1967/* 1968 @TODO add validation / handling for: 1969 - persisting a reducer which has nested _persist 1970 - handling actions that fire before reydrate is called 1971*/ 1972 1973function persistReducer(config, baseReducer) { 1974 if (false) {} 1975 1976 var version = config.version !== undefined ? config.version : DEFAULT_VERSION; 1977 var debug = config.debug || false; 1978 var stateReconciler = config.stateReconciler === undefined ? autoMergeLevel1 : config.stateReconciler; 1979 var getStoredState = config.getStoredState || getStoredState_getStoredState; 1980 var timeout = config.timeout !== undefined ? config.timeout : DEFAULT_TIMEOUT; 1981 var _persistoid = null; 1982 var _purge = false; 1983 var _paused = true; 1984 1985 var conditionalUpdate = function conditionalUpdate(state) { 1986 // update the persistoid only if we are rehydrated and not paused 1987 state._persist.rehydrated && _persistoid && !_paused && _persistoid.update(state); 1988 return state; 1989 }; 1990 1991 return function (state, action) { 1992 var _ref = state || {}, 1993 _persist = _ref._persist, 1994 rest = _objectWithoutProperties(_ref, ["_persist"]); // $FlowIgnore need to update State type 1995 1996 1997 var restState = rest; 1998 1999 if (action.type === PERSIST) { 2000 var _sealed = false; 2001 2002 var _rehydrate = function _rehydrate(payload, err) { 2003 // dev warning if we are already sealed 2004 if (false) {} // only rehydrate if we are not already sealed 2005 2006 if (!_sealed) { 2007 action.rehydrate(config.key, payload, err); 2008 _sealed = true; 2009 } 2010 }; 2011 2012 timeout && setTimeout(function () { 2013 !_sealed && _rehydrate(undefined, new Error("redux-persist: persist timed out for persist key \"".concat(config.key, "\""))); 2014 }, timeout); // @NOTE PERSIST resumes if paused. 2015 2016 _paused = false; // @NOTE only ever create persistoid once, ensure we call it at least once, even if _persist has already been set 2017 2018 if (!_persistoid) _persistoid = createPersistoid(config); // @NOTE PERSIST can be called multiple times, noop after the first 2019 2020 if (_persist) { 2021 // We still need to call the base reducer because there might be nested 2022 // uses of persistReducer which need to be aware of the PERSIST action 2023 return persistReducer_objectSpread({}, baseReducer(restState, action), { 2024 _persist: _persist 2025 }); 2026 } 2027 2028 if (typeof action.rehydrate !== 'function' || typeof action.register !== 'function') throw new Error('redux-persist: either rehydrate or register is not a function on the PERSIST action. This can happen if the action is being replayed. This is an unexplored use case, please open an issue and we will figure out a resolution.'); 2029 action.register(config.key); 2030 getStoredState(config).then(function (restoredState) { 2031 var migrate = config.migrate || function (s, v) { 2032 return Promise.resolve(s); 2033 }; 2034 2035 migrate(restoredState, version).then(function (migratedState) { 2036 _rehydrate(migratedState); 2037 }, function (migrateErr) { 2038 if (false) {} 2039 2040 _rehydrate(undefined, migrateErr); 2041 }); 2042 }, function (err) { 2043 _rehydrate(undefined, err); 2044 }); 2045 return persistReducer_objectSpread({}, baseReducer(restState, action), { 2046 _persist: { 2047 version: version, 2048 rehydrated: false 2049 } 2050 }); 2051 } else if (action.type === PURGE) { 2052 _purge = true; 2053 action.result(purgeStoredState(config)); 2054 return persistReducer_objectSpread({}, baseReducer(restState, action), { 2055 _persist: _persist 2056 }); 2057 } else if (action.type === FLUSH) { 2058 action.result(_persistoid && _persistoid.flush()); 2059 return persistReducer_objectSpread({}, baseReducer(restState, action), { 2060 _persist: _persist 2061 }); 2062 } else if (action.type === PAUSE) { 2063 _paused = true; 2064 } else if (action.type === REHYDRATE) { 2065 // noop on restState if purging 2066 if (_purge) return persistReducer_objectSpread({}, restState, { 2067 _persist: persistReducer_objectSpread({}, _persist, { 2068 rehydrated: true 2069 }) // @NOTE if key does not match, will continue to default else below 2070 2071 }); 2072 2073 if (action.key === config.key) { 2074 var reducedState = baseReducer(restState, action); 2075 var inboundState = action.payload; // only reconcile state if stateReconciler and inboundState are both defined 2076 2077 var reconciledRest = stateReconciler !== false && inboundState !== undefined ? stateReconciler(inboundState, state, reducedState, config) : reducedState; 2078 2079 var _newState = persistReducer_objectSpread({}, reconciledRest, { 2080 _persist: persistReducer_objectSpread({}, _persist, { 2081 rehydrated: true 2082 }) 2083 }); 2084 2085 return conditionalUpdate(_newState); 2086 } 2087 } // if we have not already handled PERSIST, straight passthrough 2088 2089 2090 if (!_persist) return baseReducer(state, action); // run base reducer: 2091 // is state modified ? return original : return updated 2092 2093 var newState = baseReducer(restState, action); 2094 if (newState === restState) return state; 2095 return conditionalUpdate(persistReducer_objectSpread({}, newState, { 2096 _persist: _persist 2097 })); 2098 }; 2099} 2100// EXTERNAL MODULE: ./node_modules/redux/es/redux.js 2101var redux = __webpack_require__(148); 2102 2103// CONCATENATED MODULE: ./node_modules/redux-persist/es/stateReconciler/autoMergeLevel2.js 2104function autoMergeLevel2_typeof(obj) { 2105 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 2106 autoMergeLevel2_typeof = function _typeof(obj) { 2107 return typeof obj; 2108 }; 2109 } else { 2110 autoMergeLevel2_typeof = function _typeof(obj) { 2111 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 2112 }; 2113 } 2114 2115 return autoMergeLevel2_typeof(obj); 2116} 2117 2118function autoMergeLevel2_ownKeys(object, enumerableOnly) { 2119 var keys = Object.keys(object); 2120 2121 if (Object.getOwnPropertySymbols) { 2122 var symbols = Object.getOwnPropertySymbols(object); 2123 if (enumerableOnly) symbols = symbols.filter(function (sym) { 2124 return Object.getOwnPropertyDescriptor(object, sym).enumerable; 2125 }); 2126 keys.push.apply(keys, symbols); 2127 } 2128 2129 return keys; 2130} 2131 2132function autoMergeLevel2_objectSpread(target) { 2133 for (var i = 1; i < arguments.length; i++) { 2134 var source = arguments[i] != null ? arguments[i] : {}; 2135 2136 if (i % 2) { 2137 autoMergeLevel2_ownKeys(source, true).forEach(function (key) { 2138 autoMergeLevel2_defineProperty(target, key, source[key]); 2139 }); 2140 } else if (Object.getOwnPropertyDescriptors) { 2141 Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); 2142 } else { 2143 autoMergeLevel2_ownKeys(source).forEach(function (key) {
2144 Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); 2145 }); 2146 } 2147 } 2148 2149 return target; 2150} 2151 2152function autoMergeLevel2_defineProperty(obj, key, value) { 2153 if (key in obj) { 2154 Object.defineProperty(obj, key, { 2155 value: value, 2156 enumerable: true, 2157 configurable: true, 2158 writable: true 2159 }); 2160 } else { 2161 obj[key] = value; 2162 } 2163 2164 return obj; 2165} 2166/* 2167 autoMergeLevel2: 2168 - merges 2 level of substate 2169 - skips substate if already modified 2170 - this is essentially redux-perist v4 behavior 2171*/ 2172 2173 2174function autoMergeLevel2(inboundState, originalState, reducedState, _ref) { 2175 var debug = _ref.debug; 2176 2177 var newState = autoMergeLevel2_objectSpread({}, reducedState); // only rehydrate if inboundState exists and is an object 2178 2179 2180 if (inboundState && autoMergeLevel2_typeof(inboundState) === 'object') { 2181 Object.keys(inboundState).forEach(function (key) { 2182 // ignore _persist data 2183 if (key === '_persist') return; // if reducer modifies substate, skip auto rehydration 2184 2185 if (originalState[key] !== reducedState[key]) { 2186 if (false) {} 2187 return; 2188 } 2189 2190 if (isPlainEnoughObject(reducedState[key])) { 2191 // if object is plain enough shallow merge the new values (hence "Level2") 2192 newState[key] = autoMergeLevel2_objectSpread({}, newState[key], {}, inboundState[key]); 2193 return; 2194 } // otherwise hard set 2195 2196 2197 newState[key] = inboundState[key]; 2198 }); 2199 } 2200 2201 if (false) {} 2202 return newState; 2203} 2204 2205function isPlainEnoughObject(o) { 2206 return o !== null && !Array.isArray(o) && autoMergeLevel2_typeof(o) === 'object'; 2207} 2208// CONCATENATED MODULE: ./node_modules/redux-persist/es/persistCombineReducers.js 2209 2210 2211 // combineReducers + persistReducer with stateReconciler defaulted to autoMergeLevel2 2212 2213function persistCombineReducers(config, reducers) { 2214 config.stateReconciler = config.stateReconciler === undefined ? autoMergeLevel2 : config.stateReconciler; 2215 return persistReducer(config, Object(redux["combineReducers"])(reducers)); 2216} 2217// CONCATENATED MODULE: ./node_modules/redux-persist/es/persistStore.js 2218function _toConsumableArray(arr) { 2219 return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); 2220} 2221 2222function _nonIterableSpread() { 2223 throw new TypeError("Invalid attempt to spread non-iterable instance"); 2224} 2225 2226function _iterableToArray(iter) { 2227 if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); 2228} 2229 2230function _arrayWithoutHoles(arr) { 2231 if (Array.isArray(arr)) { 2232 for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { 2233 arr2[i] = arr[i]; 2234 } 2235 2236 return arr2; 2237 } 2238} 2239 2240function persistStore_ownKeys(object, enumerableOnly) { 2241 var keys = Object.keys(object); 2242 2243 if (Object.getOwnPropertySymbols) { 2244 var symbols = Object.getOwnPropertySymbols(object); 2245 if (enumerableOnly) symbols = symbols.filter(function (sym) { 2246 return Object.getOwnPropertyDescriptor(object, sym).enumerable; 2247 }); 2248 keys.push.apply(keys, symbols); 2249 } 2250 2251 return keys; 2252} 2253 2254function persistStore_objectSpread(target) { 2255 for (var i = 1; i < arguments.length; i++) { 2256 var source = arguments[i] != null ? arguments[i] : {}; 2257 2258 if (i % 2) { 2259 persistStore_ownKeys(source, true).forEach(function (key) { 2260 persistStore_defineProperty(target, key, source[key]); 2261 }); 2262 } else if (Object.getOwnPropertyDescriptors) { 2263 Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); 2264 } else { 2265 persistStore_ownKeys(source).forEach(function (key) { 2266 Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); 2267 }); 2268 } 2269 } 2270 2271 return target; 2272} 2273 2274function persistStore_defineProperty(obj, key, value) { 2275 if (key in obj) { 2276 Object.defineProperty(obj, key, { 2277 value: value, 2278 enumerable: true, 2279 configurable: true, 2280 writable: true 2281 }); 2282 } else { 2283 obj[key] = value; 2284 } 2285 2286 return obj; 2287} 2288 2289 2290 2291var initialState = { 2292 registry: [], 2293 bootstrapped: false 2294}; 2295 2296var persistStore_persistorReducer = function persistorReducer() { 2297 var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState; 2298 var action = arguments.length > 1 ? arguments[1] : undefined; 2299 2300 switch (action.type) { 2301 case REGISTER: 2302 return persistStore_objectSpread({}, state, { 2303 registry: [].concat(_toConsumableArray(state.registry), [action.key]) 2304 }); 2305 2306 case REHYDRATE: 2307 var firstIndex = state.registry.indexOf(action.key); 2308 2309 var registry = _toConsumableArray(state.registry); 2310 2311 registry.splice(firstIndex, 1); 2312 return persistStore_objectSpread({}, state, { 2313 registry: registry, 2314 bootstrapped: registry.length === 0 2315 }); 2316 2317 default: 2318 return state; 2319 } 2320}; 2321 2322function persistStore(store, options, cb) { 2323 // help catch incorrect usage of passing PersistConfig in as PersistorOptions 2324 if (false) { var bannedKeys, optionsToTest; } 2325 2326 var boostrappedCb = cb || false; 2327 2328 var _pStore = Object(redux["createStore"])(persistStore_persistorReducer, initialState, options && options.enhancer ? options.enhancer : undefined); 2329 2330 var register = function register(key) { 2331 _pStore.dispatch({ 2332 type: REGISTER, 2333 key: key 2334 }); 2335 }; 2336 2337 var rehydrate = function rehydrate(key, payload, err) { 2338 var rehydrateAction = { 2339 type: REHYDRATE, 2340 payload: payload, 2341 err: err, 2342 key: key // dispatch to `store` to rehydrate and `persistor` to track result 2343 2344 }; 2345 store.dispatch(rehydrateAction); 2346 2347 _pStore.dispatch(rehydrateAction); 2348 2349 if (boostrappedCb && persistor.getState().bootstrapped) { 2350 boostrappedCb(); 2351 boostrappedCb = false;
2352 } 2353 }; 2354 2355 var persistor = persistStore_objectSpread({}, _pStore, { 2356 purge: function purge() { 2357 var results = []; 2358 store.dispatch({ 2359 type: PURGE, 2360 result: function result(purgeResult) { 2361 results.push(purgeResult); 2362 } 2363 }); 2364 return Promise.all(results); 2365 }, 2366 flush: function flush() { 2367 var results = []; 2368 store.dispatch({ 2369 type: FLUSH, 2370 result: function result(flushResult) { 2371 results.push(flushResult); 2372 } 2373 }); 2374 return Promise.all(results); 2375 }, 2376 pause: function pause() { 2377 store.dispatch({ 2378 type: PAUSE 2379 }); 2380 }, 2381 persist: function persist() { 2382 store.dispatch({ 2383 type: PERSIST, 2384 register: register, 2385 rehydrate: rehydrate 2386 }); 2387 } 2388 }); 2389 2390 if (!(options && options.manualPersist)) { 2391 persistor.persist(); 2392 } 2393 2394 return persistor; 2395} 2396// CONCATENATED MODULE: ./node_modules/redux-persist/es/createMigrate.js 2397 2398function createMigrate(migrations, config) { 2399 var _ref = config || {}, 2400 debug = _ref.debug; 2401 2402 return function (state, currentVersion) { 2403 if (!state) { 2404 if (false) {} 2405 return Promise.resolve(undefined); 2406 } 2407 2408 var inboundVersion = state._persist && state._persist.version !== undefined ? state._persist.version : DEFAULT_VERSION; 2409 2410 if (inboundVersion === currentVersion) { 2411 if (false) {} 2412 return Promise.resolve(state); 2413 } 2414 2415 if (inboundVersion > currentVersion) { 2416 if (false) {} 2417 return Promise.resolve(state); 2418 } 2419 2420 var migrationKeys = Object.keys(migrations).map(function (ver) { 2421 return parseInt(ver); 2422 }).filter(function (key) { 2423 return currentVersion >= key && key > inboundVersion; 2424 }).sort(function (a, b) { 2425 return a - b; 2426 }); 2427 if (false) {} 2428 2429 try { 2430 var migratedState = migrationKeys.reduce(function (state, versionKey) { 2431 if (false) {} 2432 return migrations[versionKey](state); 2433 }, state); 2434 return Promise.resolve(migratedState); 2435 } catch (err) { 2436 return Promise.reject(err); 2437 } 2438 }; 2439} 2440// CONCATENATED MODULE: ./node_modules/redux-persist/es/createTransform.js 2441function createTransform( // @NOTE inbound: transform state coming from redux on its way to being serialized and stored 2442inbound, // @NOTE outbound: transform state coming from storage, on its way to be rehydrated into redux 2443outbound) { 2444 var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 2445 var whitelist = config.whitelist || null; 2446 var blacklist = config.blacklist || null; 2447 2448 function whitelistBlacklistCheck(key) { 2449 if (whitelist && whitelist.indexOf(key) === -1) return true; 2450 if (blacklist && blacklist.indexOf(key) !== -1) return true; 2451 return false; 2452 } 2453 2454 return { 2455 in: function _in(state, key, fullState) { 2456 return !whitelistBlacklistCheck(key) && inbound ? inbound(state, key, fullState) : state; 2457 }, 2458 out: function out(state, key, fullState) { 2459 return !whitelistBlacklistCheck(key) && outbound ? outbound(state, key, fullState) : state; 2460 } 2461 }; 2462} 2463// CONCATENATED MODULE: ./node_modules/redux-persist/es/index.js 2464/* concated harmony reexport persistReducer */__webpack_require__.d(__webpack_exports__, "a", function() { return persistReducer; }); 2465/* unused concated harmony import persistCombineReducers */ 2466/* concated harmony reexport persistStore */__webpack_require__.d(__webpack_exports__, "b", function() { return persistStore; }); 2467/* unused concated harmony import createMigrate */ 2468/* unused concated harmony import createTransform */ 2469/* unused concated harmony import getStoredState */ 2470/* unused concated harmony import createPersistoid */ 2471/* unused concated harmony import purgeStoredState */ 2472/* unused concated harmony import KEY_PREFIX */ 2473/* unused concated harmony import FLUSH */ 2474/* unused concated harmony import REHYDRATE */ 2475/* unused concated harmony import PAUSE */ 2476/* unused concated harmony import PERSIST */ 2477/* unused concated harmony import PURGE */ 2478/* unused concated harmony import REGISTER */ 2479/* unused concated harmony import DEFAULT_VERSION */ 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490/***/ }), 2491 2492/***/ 650: 2493/***/ (function(module, exports, __webpack_require__) { 2494 2495"use strict"; 2496 2497 2498exports.__esModule = true; 2499exports.default = void 0; 2500 2501var _createWebStorage = _interopRequireDefault(__webpack_require__(1218)); 2502 2503function _interopRequireDefault(obj) { 2504 return obj && obj.__esModule ? obj : { 2505 default: obj 2506 }; 2507} 2508 2509var _default = (0, _createWebStorage.default)('local'); 2510 2511exports.default = _default; 2512 2513/***/ }), 2514 2515/***/ 651: 2516/***/ (function(module, exports, __webpack_require__) { 2517 2518"use strict"; 2519 2520 2521Object.defineProperty(exports, "__esModule", { 2522 value: true 2523}); 2524exports.default = immutableStateInvariantMiddleware; 2525 2526var _invariant = __webpack_require__(233); 2527 2528var _invariant2 = _interopRequireDefault(_invariant); 2529 2530var _jsonStringifySafe = __webpack_require__(1220); 2531 2532var _jsonStringifySafe2 = _interopRequireDefault(_jsonStringifySafe); 2533 2534var _isImmutable = __webpack_require__(1221); 2535 2536var _isImmutable2 = _interopRequireDefault(_isImmutable); 2537 2538var _trackForMutations = __webpack_require__(1222); 2539 2540var _trackForMutations2 = _interopRequireDefault(_trackForMutations); 2541 2542function _interopRequireDefault(obj) { 2543 return obj && obj.__esModule ? obj : { 2544 default: obj 2545 }; 2546} 2547 2548var BETWEEN_DISPATCHES_MESSAGE = ['A state mutation was detected between dispatches, in the path `%s`.', 'This may cause incorrect behavior.', '(http://redux.js.org/docs/Troubleshooting.html#never-mutate-reducer-arguments)'].join(' '); 2549var INSIDE_DISPATCH_MESSAGE = ['A state mutation was detected inside a dispatch, in the path: `%s`.', 'Take a look at the reducer(s) handling the action %s.', '(http://redux.js.org/docs/Troubleshooting.html#never-mutate-reducer-arguments)'].join(' '); 2550 2551function immutableStateInvariantMiddleware() { 2552 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2553 var _options$isImmutable = options.isImmutable, 2554 isImmutable = _options$isImmutable === undefined ? _isImmutable2.default : _options$isImmutable, 2555 ignore = options.ignore; 2556 2557 var track = _trackForMutations2.default.bind(null, isImmutable, ignore); 2558 2559 return function (_ref) { 2560 var getState = _ref.getState; 2561 var state = getState(); 2562 var tracker = track(state); 2563 var result = void 0; 2564 return function (next) { 2565 return function (action) { 2566 state = getState(); 2567 result = tracker.detectMutations(); // Track before potentially not meeting the invariant 2568 2569 tracker = track(state); 2570 (0, _invariant2.default)(!result.wasMutated, BETWEEN_DISPATCHES_MESSAGE, (result.path || []).join('.')); 2571 var dispatchedAction = next(action); 2572 state = getState(); 2573 result = tracker.detectMutations(); // Track before potentially not meeting the invariant 2574 2575 tracker = track(state); 2576 result.wasMutated && (0, _invariant2.default)(!result.wasMutated, INSIDE_DISPATCH_MESSAGE, (result.path || []).join('.'), (0, _jsonStringifySafe2.default)(action));
2577 return dispatchedAction; 2578 }; 2579 }; 2580 }; 2581} 2582 2583/***/ }), 2584 2585/***/ 652: 2586/***/ (function(module, __webpack_exports__, __webpack_require__) { 2587 2588"use strict"; 2589/* WEBPACK VAR INJECTION */(function(process) {/* unused harmony export ActionType */ 2590/* unused harmony export createPromise */ 2591/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return middleware; }); 2592/* harmony import */ var _isPromise_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(351); 2593var _slicedToArray = function () { 2594 function sliceIterator(arr, i) { 2595 var _arr = []; 2596 var _n = true; 2597 var _d = false; 2598 var _e = undefined; 2599 2600 try { 2601 for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { 2602 _arr.push(_s.value); 2603 2604 if (i && _arr.length === i) break; 2605 } 2606 } catch (err) { 2607 _d = true; 2608 _e = err; 2609 } finally { 2610 try { 2611 if (!_n && _i["return"]) _i["return"](); 2612 } finally { 2613 if (_d) throw _e; 2614 } 2615 } 2616 2617 return _arr; 2618 } 2619 2620 return function (arr, i) { 2621 if (Array.isArray(arr)) { 2622 return arr; 2623 } else if (Symbol.iterator in Object(arr)) { 2624 return sliceIterator(arr, i); 2625 } else { 2626 throw new TypeError("Invalid attempt to destructure non-iterable instance"); 2627 } 2628 }; 2629}(); 2630 2631var _extends = Object.assign || function (target) { 2632 for (var i = 1; i < arguments.length; i++) { 2633 var source = arguments[i]; 2634 2635 for (var key in source) { 2636 if (Object.prototype.hasOwnProperty.call(source, key)) { 2637 target[key] = source[key]; 2638 } 2639 } 2640 } 2641 2642 return target; 2643}; 2644 2645 2646/** 2647 * For TypeScript support: Remember to check and make sure 2648 * that `index.d.ts` is also up to date with the implementation. 2649 */ 2650 2651var ActionType = { 2652 Pending: 'PENDING', 2653 Fulfilled: 'FULFILLED', 2654 Rejected: 'REJECTED' 2655}; 2656/** 2657 * Function: createPromise 2658 * Description: The main createPromise accepts a configuration 2659 * object and returns the middleware. 2660 */ 2661 2662function createPromise() { 2663 var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 2664 var defaultTypes = [ActionType.Pending, ActionType.Fulfilled, ActionType.Rejected]; 2665 var PROMISE_TYPE_SUFFIXES = config.promiseTypeSuffixes || defaultTypes; 2666 var PROMISE_TYPE_DELIMITER = config.promiseTypeDelimiter || '_'; 2667 return function (ref) { 2668 var dispatch = ref.dispatch; 2669 return function (next) { 2670 return function (action) { 2671 /** 2672 * Instantiate variables to hold: 2673 * (1) the promise 2674 * (2) the data for optimistic updates 2675 */ 2676 var promise = void 0; 2677 var data = void 0; 2678 /** 2679 * There are multiple ways to dispatch a promise. The first step is to 2680 * determine if the promise is defined: 2681 * (a) explicitly (action.payload.promise is the promise) 2682 * (b) implicitly (action.payload is the promise) 2683 * (c) as an async function (returns a promise when called) 2684 * 2685 * If the promise is not defined in one of these three ways, we don't do 2686 * anything and move on to the next middleware in the middleware chain. 2687 */ 2688 // Step 1a: Is there a payload? 2689 2690 if (action.payload) { 2691 var PAYLOAD = action.payload; // Step 1.1: Is the promise implicitly defined? 2692 2693 if (Object(_isPromise_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(PAYLOAD)) { 2694 promise = PAYLOAD; 2695 } // Step 1.2: Is the promise explicitly defined? 2696 else if (Object(_isPromise_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(PAYLOAD.promise)) { 2697 promise = PAYLOAD.promise; 2698 data = PAYLOAD.data; 2699 } // Step 1.3: Is the promise returned by an async function? 2700 else if (typeof PAYLOAD === 'function' || typeof PAYLOAD.promise === 'function') { 2701 promise = PAYLOAD.promise ? PAYLOAD.promise() : PAYLOAD(); 2702 data = PAYLOAD.promise ? PAYLOAD.data : undefined; // Step 1.3.1: Is the return of action.payload a promise? 2703 2704 if (!Object(_isPromise_js__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(promise)) { 2705 // If not, move on to the next middleware. 2706 return next(_extends({}, action, { 2707 payload: promise 2708 })); 2709 } 2710 } // Step 1.4: If there's no promise, move on to the next middleware. 2711 else { 2712 return next(action); 2713 } // Step 1b: If there's no payload, move on to the next middleware. 2714 2715 } else { 2716 return next(action); 2717 } 2718 /** 2719 * Instantiate and define constants for: 2720 * (1) the action type 2721 * (2) the action meta 2722 */ 2723 2724 2725 var TYPE = action.type; 2726 var META = action.meta; 2727 /** 2728 * Instantiate and define constants for the action type suffixes. 2729 * These are appended to the end of the action type. 2730 */ 2731 2732 var _PROMISE_TYPE_SUFFIXE = _slicedToArray(PROMISE_TYPE_SUFFIXES, 3), 2733 PENDING = _PROMISE_TYPE_SUFFIXE[0], 2734 FULFILLED = _PROMISE_TYPE_SUFFIXE[1], 2735 REJECTED = _PROMISE_TYPE_SUFFIXE[2]; 2736 /** 2737 * Function: getAction 2738 * Description: This function constructs and returns a rejected 2739 * or fulfilled action object. The action object is based off the Flux 2740 * Standard Action (FSA). 2741 * 2742 * Given an original action with the type FOO: 2743 * 2744 * The rejected object model will be: 2745 * { 2746 * error: true, 2747 * type: 'FOO_REJECTED', 2748 * payload: ..., 2749 * meta: ... (optional) 2750 * } 2751 * 2752 * The fulfilled object model will be: 2753 * { 2754 * type: 'FOO_FULFILLED', 2755 * payload: ..., 2756 * meta: ... (optional) 2757 * } 2758 */ 2759 2760 2761 var getAction = function getAction(newPayload, isRejected) { 2762 return _extends({ 2763 // Concatenate the type string property. 2764 type: [TYPE, isRejected ? REJECTED : FULFILLED].join(PROMISE_TYPE_DELIMITER) 2765 }, newPayload === null || typeof newPayload === 'undefined' ? {} : { 2766 payload: newPayload 2767 }, META !== undefined ? { 2768 meta: META 2769 } : {}, isRejected ? { 2770 error: true 2771 } : {}); 2772 }; 2773 /** 2774 * Function: handleReject 2775 * Calls: getAction to construct the rejected action 2776 * Description: This function dispatches the rejected action and returns 2777 * the original Error object. Please note the developer is responsible 2778 * for constructing and throwing an Error object. The middleware does not 2779 * construct any Errors. 2780 */ 2781 2782 2783 var handleReject = function handleReject(reason) { 2784 var rejectedAction = getAction(reason, true); 2785 dispatch(rejectedAction); 2786 throw reason; 2787 }; 2788 /** 2789 * Function: handleFulfill 2790 * Calls: getAction to construct the fullfilled action 2791 * Description: This function dispatches the fulfilled action and 2792 * returns the success object. The success object should 2793 * contain the value and the dispatched action. 2794 */ 2795 2796 2797 var handleFulfill = function handleFulfill() { 2798 var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; 2799 var resolvedAction = getAction(value, false); 2800 dispatch(resolvedAction); 2801 return { 2802 value: value, 2803 action: resolvedAction 2804 }; 2805 }; 2806 /** 2807 * First, dispatch the pending action: 2808 * This object describes the pending state of a promise and will include 2809 * any data (for optimistic updates) and/or meta from the original action. 2810 */ 2811 2812 2813 next(_extends({ 2814 // Concatenate the type string. 2815 type: [TYPE, PENDING].join(PROMISE_TYPE_DELIMITER) 2816 }, data !== undefined ? { 2817 payload: data 2818 } : {}, META !== undefined ? { 2819 meta: META 2820 } : {})); 2821 /** 2822 * Second, dispatch a rejected or fulfilled action and move on to the 2823 * next middleware. 2824 */ 2825 2826 return promise.then(handleFulfill, handleReject); 2827 }; 2828 }; 2829 }; 2830} 2831function middleware() { 2832 var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, 2833 dispatch = _ref.dispatch; 2834 2835 if (typeof dispatch === 'function') { 2836 return createPromise()({ 2837 dispatch: dispatch 2838 }); 2839 } 2840 2841 if (process && Object({"NODE_ENV":"production","PUBLIC_URL":"","REACT_APP_VALIDATE_PERSON":"/apigee/v1/search/performSearch","REACT_APP_CAPTCHA_SITE_KEY":"6Lf9z_sUAAAAALjJwFVrr_k4_SsAb6p8gkyMY_8S","REACT_APP_POST_JOIN_SERVICE":"/ausnotifyapi/v1/submit/selfNominatedOrgDetail","REACT_APP_GET_FAQ":"/ausnotifyapi/v1/notification/helpcentre","REACT_APP_CAPTCHA_ENABLED":"true","REACT_APP_GET_NOTIFIABLE_ORGANISATIONS":"/ausnotifyapi/v1/referencedata/notifiableorganisations","REACT_APP_TUTD_URL":"https://onegov.nsw.gov.au/quickfeed/js/quickfeed.min.js","REACT_APP_GA_KEY":"G-2MBJ040SHZ","REACT_APP_BASE_URL":"https://deathnotification.gov.au","REACT_APP_POST_CONTACT_US":"/ausnotifyapi/v1/submit/feedback","REACT_APP_ENV":"prod","REACT_APP_SUBMIT":"/ausnotifyapi/v1/submit/submitApplication","REACT_APP_POST_NOMINATE_ORGANISATION":"/ausnotifyapi/v1/submit/organisationDetail","REACT_APP_GET_PARTICIPATING_ORGANISATIONS":"/ausnotifyapi/v1/referencedata/particicatingorganisations","REACT_APP_GET_ADDRESS_URL":"/ausnotifyapi/v1/referencedata/addresssearch"}) && "production" !== 'production') { 2842 // eslint-disable-next-line no-console 2843 console.warn('Redux Promise Middleware: As of version 6.0.0, the middleware library supports both preconfigured and custom configured middleware. To use a custom configuration, use the "createPromise" export and call this function with your configuration property. To use a preconfiguration, use the default export. For more help, check the upgrading guide: https://docs.psb.design/redux-promise-middleware/upgrade-guides/v6\n\nFor custom configuration:\nimport { createPromise } from \'redux-promise-middleware\';\nconst promise = createPromise({ types: { fulfilled: \'success\' } });\napplyMiddleware(promise);\n\nFor preconfiguration:\nimport promise from \'redux-promise-middleware\';\napplyMiddleware(promise);\n '); 2844 } 2845 2846 return null; 2847} 2848/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(300))) 2849 2850/***/ }), 2851 2852/***/ 653: 2853/***/ (function(module, exports, __webpack_require__) { 2854 2855"use strict"; 2856 2857 2858var compose = __webpack_require__(148).compose; 2859 2860exports.__esModule = true; 2861exports.composeWithDevTools = typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function () { 2862 if (arguments.length === 0) return undefined; 2863 if (typeof arguments[0] === 'object') return compose; 2864 return compose.apply(null, arguments); 2865}; 2866exports.devToolsEnhancer = typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function () { 2867 return function (noop) { 2868 return noop; 2869 }; 2870}; 2871 2872/***/ }), 2873 2874/***/ 654: 2875/***/ (function(module, __webpack_exports__, __webpack_require__) { 2876 2877"use strict"; 2878/** A function that accepts a potential "extra argument" value to be injected later, 2879 * and returns an instance of the thunk middleware that uses that value 2880 */ 2881function createThunkMiddleware(extraArgument) { 2882 // Standard Redux middleware definition pattern: 2883 // See: https://redux.js.org/tutorials/fundamentals/part-4-store#writing-custom-middleware 2884 var middleware = function middleware(_ref) { 2885 var dispatch = _ref.dispatch, 2886 getState = _ref.getState; 2887 return function (next) { 2888 return function (action) {
2889 // The thunk middleware looks for any functions that were passed to `store.dispatch`. 2890 // If this "action" is really a function, call it and return the result. 2891 if (typeof action === 'function') { 2892 // Inject the store's `dispatch` and `getState` methods, as well as any "extra arg" 2893 return action(dispatch, getState, extraArgument); 2894 } // Otherwise, pass the action down the middleware chain as usual 2895 2896 2897 return next(action); 2898 }; 2899 }; 2900 }; 2901 2902 return middleware; 2903} 2904 2905var thunk = createThunkMiddleware(); // Attach the factory function so users can create a customized version 2906// with whatever "extra arg" they want to inject into their thunks 2907 2908thunk.withExtraArgument = createThunkMiddleware; 2909/* harmony default export */ __webpack_exports__["a"] = (thunk); 2910 2911/***/ }), 2912 2913/***/ 655: 2914/***/ (function(module, __webpack_exports__, __webpack_require__) { 2915 2916"use strict"; 2917/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return PersistGate; }); 2918/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); 2919/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__); 2920function _typeof(obj) { 2921 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 2922 _typeof = function _typeof(obj) { 2923 return typeof obj; 2924 }; 2925 } else { 2926 _typeof = function _typeof(obj) { 2927 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 2928 }; 2929 } 2930 2931 return _typeof(obj); 2932} 2933 2934function _classCallCheck(instance, Constructor) { 2935 if (!(instance instanceof Constructor)) { 2936 throw new TypeError("Cannot call a class as a function"); 2937 } 2938} 2939 2940function _defineProperties(target, props) { 2941 for (var i = 0; i < props.length; i++) { 2942 var descriptor = props[i]; 2943 descriptor.enumerable = descriptor.enumerable || false; 2944 descriptor.configurable = true; 2945 if ("value" in descriptor) descriptor.writable = true; 2946 Object.defineProperty(target, descriptor.key, descriptor); 2947 } 2948} 2949 2950function _createClass(Constructor, protoProps, staticProps) { 2951 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 2952 if (staticProps) _defineProperties(Constructor, staticProps); 2953 return Constructor; 2954} 2955 2956function _possibleConstructorReturn(self, call) { 2957 if (call && (_typeof(call) === "object" || typeof call === "function")) { 2958 return call; 2959 } 2960 2961 return _assertThisInitialized(self); 2962} 2963 2964function _getPrototypeOf(o) { 2965 _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { 2966 return o.__proto__ || Object.getPrototypeOf(o); 2967 }; 2968 return _getPrototypeOf(o); 2969} 2970 2971function _assertThisInitialized(self) { 2972 if (self === void 0) { 2973 throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); 2974 } 2975 2976 return self; 2977} 2978 2979function _inherits(subClass, superClass) { 2980 if (typeof superClass !== "function" && superClass !== null) { 2981 throw new TypeError("Super expression must either be null or a function"); 2982 } 2983 2984 subClass.prototype = Object.create(superClass && superClass.prototype, { 2985 constructor: { 2986 value: subClass, 2987 writable: true, 2988 configurable: true 2989 } 2990 }); 2991 if (superClass) _setPrototypeOf(subClass, superClass); 2992} 2993 2994function _setPrototypeOf(o, p) { 2995 _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { 2996 o.__proto__ = p; 2997 return o; 2998 }; 2999 3000 return _setPrototypeOf(o, p); 3001} 3002 3003function _defineProperty(obj, key, value) { 3004 if (key in obj) { 3005 Object.defineProperty(obj, key, { 3006 value: value, 3007 enumerable: true, 3008 configurable: true, 3009 writable: true 3010 }); 3011 } else { 3012 obj[key] = value; 3013 } 3014 3015 return obj; 3016} 3017 3018 // eslint-disable-line import/no-unresolved 3019 3020var PersistGate = /*#__PURE__*/function (_PureComponent) { 3021 _inherits(PersistGate, _PureComponent); 3022 3023 function PersistGate() { 3024 var _getPrototypeOf2; 3025 3026 var _this; 3027 3028 _classCallCheck(this, PersistGate); 3029 3030 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 3031 args[_key] = arguments[_key]; 3032 } 3033 3034 _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(PersistGate)).call.apply(_getPrototypeOf2, [this].concat(args))); 3035 3036 _defineProperty(_assertThisInitialized(_this), "state", { 3037 bootstrapped: false 3038 }); 3039 3040 _defineProperty(_assertThisInitialized(_this), "_unsubscribe", void 0); 3041 3042 _defineProperty(_assertThisInitialized(_this), "handlePersistorState", function () { 3043 var persistor = _this.props.persistor; 3044 3045 var _persistor$getState = persistor.getState(), 3046 bootstrapped = _persistor$getState.bootstrapped; 3047 3048 if (bootstrapped) { 3049 if (_this.props.onBeforeLift) { 3050 Promise.resolve(_this.props.onBeforeLift()).finally(function () { 3051 return _this.setState({ 3052 bootstrapped: true 3053 }); 3054 }); 3055 } else { 3056 _this.setState({ 3057 bootstrapped: true 3058 }); 3059 } 3060 3061 _this._unsubscribe && _this._unsubscribe(); 3062 } 3063 }); 3064 3065 return _this; 3066 } 3067 3068 _createClass(PersistGate, [{ 3069 key: "componentDidMount", 3070 value: function componentDidMount() { 3071 this._unsubscribe = this.props.persistor.subscribe(this.handlePersistorState); 3072 this.handlePersistorState(); 3073 } 3074 }, { 3075 key: "componentWillUnmount", 3076 value: function componentWillUnmount() { 3077 this._unsubscribe && this._unsubscribe(); 3078 } 3079 }, { 3080 key: "render", 3081 value: function render() { 3082 if (false) {} 3083 3084 if (typeof this.props.children === 'function') { 3085 return this.props.children(this.state.bootstrapped); 3086 } 3087 3088 return this.state.bootstrapped ? this.props.children : this.props.loading; 3089 } 3090 }]); 3091 3092 return PersistGate; 3093}(react__WEBPACK_IMPORTED_MODULE_0__["PureComponent"]); 3094 3095_defineProperty(PersistGate, "defaultProps", { 3096 children: null, 3097 loading: null 3098}); 3099 3100/***/ }) 3101 3102}]);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.