1(globalThis["webpackChunkdfmexbyn_beyond_oauth_ui"] = globalThis["webpackChunkdfmexbyn_beyond_oauth_ui"] || []).push([["file-e5bca7e4"],{ 2 3/***/ 4625: 4/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 5 6"use strict"; 7/* harmony export */ __webpack_require__.d(__webpack_exports__, { 8/* harmony export */ Kd: () => (/* binding */ BrowserRouter) 9/* harmony export */ }); 10/* unused harmony exports HashRouter, Link, NavLink */ 11/* harmony import */ var react_router__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3205); 12/* harmony import */ var _babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7387); 13/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6540); 14/* harmony import */ var history__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5591); 15/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(8168); 16/* harmony import */ var _babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8587); 17/* harmony import */ var tiny_invariant__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1561); 18 19 20 21 22 23 24 25 26 27 28 29/** 30 * The public API for a <Router> that uses HTML5 history. 31 */ 32 33var BrowserRouter = /*#__PURE__*/function (_React$Component) { 34 (0,_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(BrowserRouter, _React$Component); 35 36 function BrowserRouter() { 37 var _this; 38 39 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 40 args[_key] = arguments[_key]; 41 } 42 43 _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this; 44 _this.history = (0,history__WEBPACK_IMPORTED_MODULE_2__/* .createBrowserHistory */ .zR)(_this.props); 45 return _this; 46 } 47 48 var _proto = BrowserRouter.prototype; 49 50 _proto.render = function render() { 51 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(react_router__WEBPACK_IMPORTED_MODULE_3__/* .Router */ .Ix, { 52 history: this.history, 53 children: this.props.children 54 }); 55 }; 56 57 return BrowserRouter; 58}(react__WEBPACK_IMPORTED_MODULE_0__.Component); 59 60if (false) {} 61 62/** 63 * The public API for a <Router> that uses window.location.hash. 64 */ 65 66var HashRouter = /*#__PURE__*/function (_React$Component) { 67 (0,_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(HashRouter, _React$Component); 68 69 function HashRouter() { 70 var _this; 71 72 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 73 args[_key] = arguments[_key]; 74 } 75 76 _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this; 77 _this.history = (0,history__WEBPACK_IMPORTED_MODULE_2__/* .createHashHistory */ .TM)(_this.props); 78 return _this; 79 } 80 81 var _proto = HashRouter.prototype; 82 83 _proto.render = function render() { 84 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(react_router__WEBPACK_IMPORTED_MODULE_3__/* .Router */ .Ix, { 85 history: this.history, 86 children: this.props.children 87 }); 88 }; 89 90 return HashRouter; 91}(react__WEBPACK_IMPORTED_MODULE_0__.Component); 92 93if (false) {} 94 95var resolveToLocation = function resolveToLocation(to, currentLocation) { 96 return typeof to === "function" ? to(currentLocation) : to; 97}; 98var normalizeToLocation = function normalizeToLocation(to, currentLocation) { 99 return typeof to === "string" ? (0,history__WEBPACK_IMPORTED_MODULE_2__/* .createLocation */ .yJ)(to, null, null, currentLocation) : to; 100}; 101 102var forwardRefShim = function forwardRefShim(C) { 103 return C; 104}; 105 106var forwardRef = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef; 107 108if (typeof forwardRef === "undefined") { 109 forwardRef = forwardRefShim; 110} 111 112function isModifiedEvent(event) { 113 return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey); 114} 115 116var LinkAnchor = forwardRef(function (_ref, forwardedRef) { 117 var innerRef = _ref.innerRef, 118 navigate = _ref.navigate, 119 _onClick = _ref.onClick, 120 rest = (0,_babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(_ref, ["innerRef", "navigate", "onClick"]); 121 122 var target = rest.target; 123 124 var props = (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A)({}, rest, { 125 onClick: function onClick(event) {
126 try { 127 if (_onClick) _onClick(event); 128 } catch (ex) { 129 event.preventDefault(); 130 throw ex; 131 } 132 133 if (!event.defaultPrevented && // onClick prevented default 134 event.button === 0 && ( // ignore everything but left clicks 135 !target || target === "_self") && // let browser handle "target=_blank" etc. 136 !isModifiedEvent(event) // ignore clicks with modifier keys 137 ) { 138 event.preventDefault(); 139 navigate(); 140 } 141 } 142 }); // React 15 compat 143 144 145 if (forwardRefShim !== forwardRef) { 146 props.ref = forwardedRef || innerRef; 147 } else { 148 props.ref = innerRef; 149 } 150 /* eslint-disable-next-line jsx-a11y/anchor-has-content */ 151 152 153 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("a", props); 154}); 155 156if (false) {} 157/** 158 * The public API for rendering a history-aware <a>. 159 */ 160 161 162var Link = forwardRef(function (_ref2, forwardedRef) { 163 var _ref2$component = _ref2.component, 164 component = _ref2$component === void 0 ? LinkAnchor : _ref2$component, 165 replace = _ref2.replace, 166 to = _ref2.to, 167 innerRef = _ref2.innerRef, 168 rest = (0,_babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(_ref2, ["component", "replace", "to", "innerRef"]); 169 170 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(react_router__WEBPACK_IMPORTED_MODULE_3__/* .__RouterContext */ .XZ.Consumer, null, function (context) { 171 !context ? false ? 0 : (0,tiny_invariant__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A)(false) : void 0; 172 var history = context.history; 173 var location = normalizeToLocation(resolveToLocation(to, context.location), context.location); 174 var href = location ? history.createHref(location) : ""; 175 176 var props = (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A)({}, rest, { 177 href: href, 178 navigate: function navigate() { 179 var location = resolveToLocation(to, context.location); 180 var isDuplicateNavigation = (0,history__WEBPACK_IMPORTED_MODULE_2__/* .createPath */ .AO)(context.location) === (0,history__WEBPACK_IMPORTED_MODULE_2__/* .createPath */ .AO)(normalizeToLocation(location)); 181 var method = replace || isDuplicateNavigation ? history.replace : history.push; 182 method(location); 183 } 184 }); // React 15 compat 185 186 187 if (forwardRefShim !== forwardRef) { 188 props.ref = forwardedRef || innerRef; 189 } else { 190 props.innerRef = innerRef; 191 } 192 193 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(component, props); 194 }); 195}); 196 197if (false) { var refType, toType; } 198 199var forwardRefShim$1 = function forwardRefShim(C) { 200 return C; 201}; 202 203var forwardRef$1 = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef; 204 205if (typeof forwardRef$1 === "undefined") { 206 forwardRef$1 = forwardRefShim$1; 207} 208 209function joinClassnames() { 210 for (var _len = arguments.length, classnames = new Array(_len), _key = 0; _key < _len; _key++) { 211 classnames[_key] = arguments[_key]; 212 } 213 214 return classnames.filter(function (i) { 215 return i; 216 }).join(" "); 217} 218/** 219 * A <Link> wrapper that knows if it's "active" or not. 220 */ 221 222 223var NavLink = forwardRef$1(function (_ref, forwardedRef) { 224 var _ref$ariaCurrent = _ref["aria-current"], 225 ariaCurrent = _ref$ariaCurrent === void 0 ? "page" : _ref$ariaCurrent, 226 _ref$activeClassName = _ref.activeClassName, 227 activeClassName = _ref$activeClassName === void 0 ? "active" : _ref$activeClassName, 228 activeStyle = _ref.activeStyle, 229 classNameProp = _ref.className, 230 exact = _ref.exact, 231 isActiveProp = _ref.isActive, 232 locationProp = _ref.location, 233 sensitive = _ref.sensitive, 234 strict = _ref.strict, 235 styleProp = _ref.style, 236 to = _ref.to, 237 innerRef = _ref.innerRef, 238 rest = (0,_babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(_ref, ["aria-current", "activeClassName", "activeStyle", "className", "exact", "isActive", "location", "sensitive", "strict", "style", "to", "innerRef"]); 239 240 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(react_router__WEBPACK_IMPORTED_MODULE_3__/* .__RouterContext */ .XZ.Consumer, null, function (context) { 241 !context ? false ? 0 : (0,tiny_invariant__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A)(false) : void 0; 242 var currentLocation = locationProp || context.location; 243 var toLocation = normalizeToLocation(resolveToLocation(to, currentLocation), currentLocation); 244 var path = toLocation.pathname; // Regex taken from: https://github.com/pillarjs/path-to-regexp/blob/master/index.js#L202 245 246 var escapedPath = path && path.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1"); 247 var match = escapedPath ? (0,react_router__WEBPACK_IMPORTED_MODULE_3__/* .matchPath */ .B6)(currentLocation.pathname, { 248 path: escapedPath, 249 exact: exact, 250 sensitive: sensitive,
251 strict: strict 252 }) : null; 253 var isActive = !!(isActiveProp ? isActiveProp(match, currentLocation) : match); 254 var className = typeof classNameProp === "function" ? classNameProp(isActive) : classNameProp; 255 var style = typeof styleProp === "function" ? styleProp(isActive) : styleProp; 256 257 if (isActive) { 258 className = joinClassnames(className, activeClassName); 259 style = (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A)({}, style, activeStyle); 260 } 261 262 var props = (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A)({ 263 "aria-current": isActive && ariaCurrent || null, 264 className: className, 265 style: style, 266 to: toLocation 267 }, rest); // React 15 compat 268 269 270 if (forwardRefShim$1 !== forwardRef$1) { 271 props.ref = forwardedRef || innerRef; 272 } else { 273 props.innerRef = innerRef; 274 } 275 276 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(Link, props); 277 }); 278}); 279 280if (false) { var ariaCurrentType; } 281 282 283//# sourceMappingURL=react-router-dom.js.map 284 285 286/***/ }), 287 288/***/ 5591: 289/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 290 291"use strict"; 292 293// EXPORTS 294__webpack_require__.d(__webpack_exports__, { 295 zR: () => (/* binding */ createBrowserHistory), 296 TM: () => (/* binding */ createHashHistory), 297 yJ: () => (/* binding */ createLocation), 298 sC: () => (/* binding */ createMemoryHistory), 299 AO: () => (/* binding */ createPath), 300 Fu: () => (/* binding */ locationsAreEqual) 301}); 302 303// UNUSED EXPORTS: parsePath 304 305// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js 306var esm_extends = __webpack_require__(8168); 307;// ./node_modules/react-router-dom/node_modules/resolve-pathname/esm/resolve-pathname.js 308function isAbsolute(pathname) { 309 return pathname.charAt(0) === '/'; 310} 311 312// About 1.5x faster than the two-arg version of Array#splice() 313function spliceOne(list, index) { 314 for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) { 315 list[i] = list[k]; 316 } 317 318 list.pop(); 319} 320 321// This implementation is based heavily on node's url.parse 322function resolvePathname(to, from) { 323 if (from === undefined) from = ''; 324 325 var toParts = (to && to.split('/')) || []; 326 var fromParts = (from && from.split('/')) || []; 327 328 var isToAbs = to && isAbsolute(to); 329 var isFromAbs = from && isAbsolute(from); 330 var mustEndAbs = isToAbs || isFromAbs; 331 332 if (to && isAbsolute(to)) { 333 // to is absolute 334 fromParts = toParts; 335 } else if (toParts.length) { 336 // to is relative, drop the filename 337 fromParts.pop(); 338 fromParts = fromParts.concat(toParts); 339 } 340 341 if (!fromParts.length) return '/'; 342 343 var hasTrailingSlash; 344 if (fromParts.length) { 345 var last = fromParts[fromParts.length - 1]; 346 hasTrailingSlash = last === '.' || last === '..' || last === ''; 347 } else { 348 hasTrailingSlash = false; 349 } 350 351 var up = 0; 352 for (var i = fromParts.length; i >= 0; i--) { 353 var part = fromParts[i]; 354 355 if (part === '.') { 356 spliceOne(fromParts, i); 357 } else if (part === '..') { 358 spliceOne(fromParts, i); 359 up++; 360 } else if (up) { 361 spliceOne(fromParts, i); 362 up--; 363 } 364 } 365 366 if (!mustEndAbs) for (; up--; up) fromParts.unshift('..'); 367 368 if ( 369 mustEndAbs && 370 fromParts[0] !== '' && 371 (!fromParts[0] || !isAbsolute(fromParts[0])) 372 ) 373 fromParts.unshift(''); 374 375 var result = fromParts.join('/'); 376 377 if (hasTrailingSlash && result.substr(-1) !== '/') result += '/'; 378 379 return result; 380} 381 382/* harmony default export */ const resolve_pathname = (resolvePathname); 383 384;// ./node_modules/react-router-dom/node_modules/value-equal/esm/value-equal.js 385function value_equal_valueOf(obj) { 386 return obj.valueOf ? obj.valueOf() : Object.prototype.valueOf.call(obj); 387} 388 389function valueEqual(a, b) { 390 // Test for strict equality first. 391 if (a === b) return true; 392 393 // Otherwise, if either of them == null they are not equal. 394 if (a == null || b == null) return false; 395 396 if (Array.isArray(a)) { 397 return ( 398 Array.isArray(b) && 399 a.length === b.length && 400 a.every(function(item, index) { 401 return valueEqual(item, b[index]); 402 }) 403 ); 404 } 405 406 if (typeof a === 'object' || typeof b === 'object') { 407 var aValue = value_equal_valueOf(a); 408 var bValue = value_equal_valueOf(b); 409 410 if (aValue !== a || bValue !== b) return valueEqual(aValue, bValue); 411 412 return Object.keys(Object.assign({}, a, b)).every(function(key) { 413 return valueEqual(a[key], b[key]); 414 }); 415 } 416 417 return false;
418} 419 420/* harmony default export */ const value_equal = (valueEqual); 421 422// EXTERNAL MODULE: ./node_modules/tiny-invariant/dist/esm/tiny-invariant.js 423var tiny_invariant = __webpack_require__(1561); 424;// ./node_modules/react-router-dom/node_modules/history/esm/history.js 425 426 427 428 429 430 431function addLeadingSlash(path) { 432 return path.charAt(0) === '/' ? path : '/' + path; 433} 434function stripLeadingSlash(path) { 435 return path.charAt(0) === '/' ? path.substr(1) : path; 436} 437function hasBasename(path, prefix) { 438 return path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && '/?#'.indexOf(path.charAt(prefix.length)) !== -1; 439} 440function stripBasename(path, prefix) { 441 return hasBasename(path, prefix) ? path.substr(prefix.length) : path; 442} 443function stripTrailingSlash(path) { 444 return path.charAt(path.length - 1) === '/' ? path.slice(0, -1) : path; 445} 446function parsePath(path) { 447 var pathname = path || '/'; 448 var search = ''; 449 var hash = ''; 450 var hashIndex = pathname.indexOf('#'); 451 452 if (hashIndex !== -1) { 453 hash = pathname.substr(hashIndex); 454 pathname = pathname.substr(0, hashIndex); 455 } 456 457 var searchIndex = pathname.indexOf('?'); 458 459 if (searchIndex !== -1) { 460 search = pathname.substr(searchIndex); 461 pathname = pathname.substr(0, searchIndex); 462 } 463 464 return { 465 pathname: pathname, 466 search: search === '?' ? '' : search, 467 hash: hash === '#' ? '' : hash 468 }; 469} 470function createPath(location) { 471 var pathname = location.pathname, 472 search = location.search, 473 hash = location.hash; 474 var path = pathname || '/'; 475 if (search && search !== '?') path += search.charAt(0) === '?' ? search : "?" + search; 476 if (hash && hash !== '#') path += hash.charAt(0) === '#' ? hash : "#" + hash; 477 return path; 478} 479 480function createLocation(path, state, key, currentLocation) { 481 var location; 482 483 if (typeof path === 'string') { 484 // Two-arg form: push(path, state) 485 location = parsePath(path); 486 location.state = state; 487 } else { 488 // One-arg form: push(location) 489 location = (0,esm_extends/* default */.A)({}, path); 490 if (location.pathname === undefined) location.pathname = ''; 491 492 if (location.search) { 493 if (location.search.charAt(0) !== '?') location.search = '?' + location.search; 494 } else { 495 location.search = ''; 496 } 497 498 if (location.hash) { 499 if (location.hash.charAt(0) !== '#') location.hash = '#' + location.hash; 500 } else { 501 location.hash = ''; 502 } 503 504 if (state !== undefined && location.state === undefined) location.state = state; 505 } 506 507 try { 508 location.pathname = decodeURI(location.pathname); 509 } catch (e) { 510 if (e instanceof URIError) { 511 throw new URIError('Pathname "' + location.pathname + '" could not be decoded. ' + 'This is likely caused by an invalid percent-encoding.'); 512 } else { 513 throw e; 514 } 515 } 516 517 if (key) location.key = key; 518 519 if (currentLocation) { 520 // Resolve incomplete/relative pathname relative to current location. 521 if (!location.pathname) { 522 location.pathname = currentLocation.pathname; 523 } else if (location.pathname.charAt(0) !== '/') { 524 location.pathname = resolve_pathname(location.pathname, currentLocation.pathname); 525 } 526 } else { 527 // When there is no prior location and pathname is empty, set it to / 528 if (!location.pathname) { 529 location.pathname = '/'; 530 } 531 } 532 533 return location; 534} 535function locationsAreEqual(a, b) { 536 return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash && a.key === b.key && value_equal(a.state, b.state); 537} 538 539function createTransitionManager() { 540 var prompt = null; 541 542 function setPrompt(nextPrompt) { 543 false ? 0 : void 0; 544 prompt = nextPrompt; 545 return function () { 546 if (prompt === nextPrompt) prompt = null; 547 }; 548 } 549 550 function confirmTransitionTo(location, action, getUserConfirmation, callback) { 551 // TODO: If another transition starts while we're still confirming 552 // the previous one, we may end up in a weird state. Figure out the 553 // best way to handle this. 554 if (prompt != null) { 555 var result = typeof prompt === 'function' ? prompt(location, action) : prompt; 556 557 if (typeof result === 'string') { 558 if (typeof getUserConfirmation === 'function') { 559 getUserConfirmation(result, callback); 560 } else { 561 false ? 0 : void 0; 562 callback(true); 563 } 564 } else { 565 // Return false from a transition hook to cancel the transition. 566 callback(result !== false); 567 } 568 } else { 569 callback(true); 570 } 571 } 572 573 var listeners = []; 574 575 function appendListener(fn) { 576 var isActive = true; 577 578 function listener() { 579 if (isActive) fn.apply(void 0, arguments); 580 } 581 582 listeners.push(listener); 583 return function () { 584 isActive = false;
585 listeners = listeners.filter(function (item) { 586 return item !== listener; 587 }); 588 }; 589 } 590 591 function notifyListeners() { 592 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 593 args[_key] = arguments[_key]; 594 } 595 596 listeners.forEach(function (listener) { 597 return listener.apply(void 0, args); 598 }); 599 } 600 601 return { 602 setPrompt: setPrompt, 603 confirmTransitionTo: confirmTransitionTo, 604 appendListener: appendListener, 605 notifyListeners: notifyListeners 606 }; 607} 608 609var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement); 610function getConfirmation(message, callback) { 611 callback(window.confirm(message)); // eslint-disable-line no-alert 612} 613/** 614 * Returns true if the HTML5 history API is supported. Taken from Modernizr. 615 * 616 * https://github.com/Modernizr/Modernizr/blob/master/LICENSE 617 * https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js 618 * changed to avoid false negatives for Windows Phones: https://github.com/reactjs/react-router/issues/586 619 */ 620 621function supportsHistory() { 622 var ua = window.navigator.userAgent; 623 if ((ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) && ua.indexOf('Mobile Safari') !== -1 && ua.indexOf('Chrome') === -1 && ua.indexOf('Windows Phone') === -1) return false; 624 return window.history && 'pushState' in window.history; 625} 626/** 627 * Returns true if browser fires popstate on hash change. 628 * IE10 and IE11 do not. 629 */ 630 631function supportsPopStateOnHashChange() { 632 return window.navigator.userAgent.indexOf('Trident') === -1; 633} 634/** 635 * Returns false if using go(n) with hash history causes a full page reload. 636 */ 637 638function supportsGoWithoutReloadUsingHash() { 639 return window.navigator.userAgent.indexOf('Firefox') === -1; 640} 641/** 642 * Returns true if a given popstate event is an extraneous WebKit event. 643 * Accounts for the fact that Chrome on iOS fires real popstate events 644 * containing undefined state when pressing the back button. 645 */ 646 647function isExtraneousPopstateEvent(event) { 648 return event.state === undefined && navigator.userAgent.indexOf('CriOS') === -1; 649} 650 651var PopStateEvent = 'popstate'; 652var HashChangeEvent = 'hashchange'; 653 654function getHistoryState() { 655 try { 656 return window.history.state || {}; 657 } catch (e) { 658 // IE 11 sometimes throws when accessing window.history.state 659 // See https://github.com/ReactTraining/history/pull/289 660 return {}; 661 } 662} 663/** 664 * Creates a history object that uses the HTML5 history API including 665 * pushState, replaceState, and the popstate event. 666 */ 667 668 669function createBrowserHistory(props) { 670 if (props === void 0) { 671 props = {}; 672 } 673 674 !canUseDOM ? false ? 0 : (0,tiny_invariant/* default */.A)(false) : void 0; 675 var globalHistory = window.history; 676 var canUseHistory = supportsHistory(); 677 var needsHashChangeListener = !supportsPopStateOnHashChange(); 678 var _props = props, 679 _props$forceRefresh = _props.forceRefresh, 680 forceRefresh = _props$forceRefresh === void 0 ? false : _props$forceRefresh, 681 _props$getUserConfirm = _props.getUserConfirmation, 682 getUserConfirmation = _props$getUserConfirm === void 0 ? getConfirmation : _props$getUserConfirm, 683 _props$keyLength = _props.keyLength, 684 keyLength = _props$keyLength === void 0 ? 6 : _props$keyLength; 685 var basename = props.basename ? stripTrailingSlash(addLeadingSlash(props.basename)) : ''; 686 687 function getDOMLocation(historyState) { 688 var _ref = historyState || {}, 689 key = _ref.key, 690 state = _ref.state; 691 692 var _window$location = window.location, 693 pathname = _window$location.pathname, 694 search = _window$location.search, 695 hash = _window$location.hash; 696 var path = pathname + search + hash; 697 false ? 0 : void 0; 698 if (basename) path = stripBasename(path, basename); 699 return createLocation(path, state, key); 700 } 701 702 function createKey() { 703 return Math.random().toString(36).substr(2, keyLength); 704 } 705 706 var transitionManager = createTransitionManager(); 707 708 function setState(nextState) { 709 (0,esm_extends/* default */.A)(history, nextState); 710 711 history.length = globalHistory.length; 712 transitionManager.notifyListeners(history.location, history.action); 713 } 714 715 function handlePopState(event) { 716 // Ignore extraneous popstate events in WebKit. 717 if (isExtraneousPopstateEvent(event)) return; 718 handlePop(getDOMLocation(event.state)); 719 } 720 721 function handleHashChange() { 722 handlePop(getDOMLocation(getHistoryState())); 723 } 724 725 var forceNextPop = false;
726 727 function handlePop(location) { 728 if (forceNextPop) { 729 forceNextPop = false; 730 setState(); 731 } else { 732 var action = 'POP'; 733 transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { 734 if (ok) { 735 setState({ 736 action: action, 737 location: location 738 }); 739 } else { 740 revertPop(location); 741 } 742 }); 743 } 744 } 745 746 function revertPop(fromLocation) { 747 var toLocation = history.location; // TODO: We could probably make this more reliable by 748 // keeping a list of keys we've seen in sessionStorage. 749 // Instead, we just default to 0 for keys we don't know. 750 751 var toIndex = allKeys.indexOf(toLocation.key); 752 if (toIndex === -1) toIndex = 0; 753 var fromIndex = allKeys.indexOf(fromLocation.key); 754 if (fromIndex === -1) fromIndex = 0; 755 var delta = toIndex - fromIndex; 756 757 if (delta) { 758 forceNextPop = true; 759 go(delta); 760 } 761 } 762 763 var initialLocation = getDOMLocation(getHistoryState()); 764 var allKeys = [initialLocation.key]; // Public interface 765 766 function createHref(location) { 767 return basename + createPath(location); 768 } 769 770 function push(path, state) { 771 false ? 0 : void 0; 772 var action = 'PUSH'; 773 var location = createLocation(path, state, createKey(), history.location); 774 transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { 775 if (!ok) return; 776 var href = createHref(location); 777 var key = location.key, 778 state = location.state; 779 780 if (canUseHistory) { 781 globalHistory.pushState({ 782 key: key, 783 state: state 784 }, null, href); 785 786 if (forceRefresh) { 787 window.location.href = href; 788 } else { 789 var prevIndex = allKeys.indexOf(history.location.key); 790 var nextKeys = allKeys.slice(0, prevIndex + 1); 791 nextKeys.push(location.key); 792 allKeys = nextKeys; 793 setState({ 794 action: action, 795 location: location 796 }); 797 } 798 } else { 799 false ? 0 : void 0; 800 window.location.href = href; 801 } 802 }); 803 } 804 805 function replace(path, state) { 806 false ? 0 : void 0; 807 var action = 'REPLACE'; 808 var location = createLocation(path, state, createKey(), history.location); 809 transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { 810 if (!ok) return; 811 var href = createHref(location); 812 var key = location.key, 813 state = location.state; 814 815 if (canUseHistory) { 816 globalHistory.replaceState({ 817 key: key, 818 state: state 819 }, null, href); 820 821 if (forceRefresh) { 822 window.location.replace(href); 823 } else { 824 var prevIndex = allKeys.indexOf(history.location.key); 825 if (prevIndex !== -1) allKeys[prevIndex] = location.key; 826 setState({ 827 action: action, 828 location: location 829 }); 830 } 831 } else { 832 false ? 0 : void 0; 833 window.location.replace(href); 834 } 835 }); 836 } 837 838 function go(n) { 839 globalHistory.go(n); 840 } 841 842 function goBack() { 843 go(-1); 844 } 845 846 function goForward() { 847 go(1); 848 } 849 850 var listenerCount = 0; 851 852 function checkDOMListeners(delta) { 853 listenerCount += delta; 854 855 if (listenerCount === 1 && delta === 1) { 856 window.addEventListener(PopStateEvent, handlePopState); 857 if (needsHashChangeListener) window.addEventListener(HashChangeEvent, handleHashChange); 858 } else if (listenerCount === 0) { 859 window.removeEventListener(PopStateEvent, handlePopState); 860 if (needsHashChangeListener) window.removeEventListener(HashChangeEvent, handleHashChange); 861 } 862 } 863 864 var isBlocked = false; 865 866 function block(prompt) { 867 if (prompt === void 0) { 868 prompt = false; 869 } 870 871 var unblock = transitionManager.setPrompt(prompt); 872 873 if (!isBlocked) { 874 checkDOMListeners(1); 875 isBlocked = true; 876 } 877 878 return function () { 879 if (isBlocked) { 880 isBlocked = false; 881 checkDOMListeners(-1); 882 } 883 884 return unblock(); 885 }; 886 } 887 888 function listen(listener) { 889 var unlisten = transitionManager.appendListener(listener); 890 checkDOMListeners(1); 891 return function () { 892 checkDOMListeners(-1); 893 unlisten(); 894 }; 895 } 896 897 var history = { 898 length: globalHistory.length, 899 action: 'POP', 900 location: initialLocation, 901 createHref: createHref, 902 push: push, 903 replace: replace, 904 go: go, 905 goBack: goBack, 906 goForward: goForward, 907 block: block, 908 listen: listen 909 }; 910 return history; 911} 912 913var HashChangeEvent$1 = 'hashchange'; 914var HashPathCoders = { 915 hashbang: { 916 encodePath: function encodePath(path) { 917 return path.charAt(0) === '!' ? path : '!/' + stripLeadingSlash(path); 918 }, 919 decodePath: function decodePath(path) { 920 return path.charAt(0) === '!' ? path.substr(1) : path; 921 } 922 }, 923 noslash: { 924 encodePath: stripLeadingSlash, 925 decodePath: addLeadingSlash 926 }, 927 slash: { 928 encodePath: addLeadingSlash, 929 decodePath: addLeadingSlash 930 } 931}; 932 933function stripHash(url) { 934 var hashIndex = url.indexOf('#'); 935 return hashIndex === -1 ? url : url.slice(0, hashIndex); 936} 937 938function getHashPath() { 939 // We can't use window.location.hash here because it's not 940 // consistent across browsers - Firefox will pre-decode it! 941 var href = window.location.href; 942 var hashIndex = href.indexOf('#'); 943 return hashIndex === -1 ? '' : href.substring(hashIndex + 1); 944} 945 946function pushHashPath(path) { 947 window.location.hash = path; 948} 949 950function replaceHashPath(path) { 951 window.location.replace(stripHash(window.location.href) + '#' + path); 952} 953 954function createHashHistory(props) { 955 if (props === void 0) { 956 props = {}; 957 } 958 959 !canUseDOM ? false ? 0 : (0,tiny_invariant/* default */.A)(false) : void 0; 960 var globalHistory = window.history; 961 var canGoWithoutReload = supportsGoWithoutReloadUsingHash(); 962 var _props = props, 963 _props$getUserConfirm = _props.getUserConfirmation, 964 getUserConfirmation = _props$getUserConfirm === void 0 ? getConfirmation : _props$getUserConfirm, 965 _props$hashType = _props.hashType, 966 hashType = _props$hashType === void 0 ? 'slash' : _props$hashType; 967 var basename = props.basename ? stripTrailingSlash(addLeadingSlash(props.basename)) : ''; 968 var _HashPathCoders$hashT = HashPathCoders[hashType], 969 encodePath = _HashPathCoders$hashT.encodePath, 970 decodePath = _HashPathCoders$hashT.decodePath; 971 972 function getDOMLocation() { 973 var path = decodePath(getHashPath()); 974 false ? 0 : void 0; 975 if (basename) path = stripBasename(path, basename); 976 return createLocation(path); 977 } 978 979 var transitionManager = createTransitionManager(); 980 981 function setState(nextState) { 982 (0,esm_extends/* default */.A)(history, nextState); 983 984 history.length = globalHistory.length; 985 transitionManager.notifyListeners(history.location, history.action); 986 } 987 988 var forceNextPop = false;
989 var ignorePath = null; 990 991 function locationsAreEqual$$1(a, b) { 992 return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash; 993 } 994 995 function handleHashChange() { 996 var path = getHashPath(); 997 var encodedPath = encodePath(path); 998 999 if (path !== encodedPath) { 1000 // Ensure we always have a properly-encoded hash. 1001 replaceHashPath(encodedPath); 1002 } else { 1003 var location = getDOMLocation(); 1004 var prevLocation = history.location; 1005 if (!forceNextPop && locationsAreEqual$$1(prevLocation, location)) return; // A hashchange doesn't always == location change. 1006 1007 if (ignorePath === createPath(location)) return; // Ignore this change; we already setState in push/replace. 1008 1009 ignorePath = null; 1010 handlePop(location); 1011 } 1012 } 1013 1014 function handlePop(location) { 1015 if (forceNextPop) { 1016 forceNextPop = false; 1017 setState(); 1018 } else { 1019 var action = 'POP'; 1020 transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { 1021 if (ok) { 1022 setState({ 1023 action: action, 1024 location: location 1025 }); 1026 } else { 1027 revertPop(location); 1028 } 1029 }); 1030 } 1031 } 1032 1033 function revertPop(fromLocation) { 1034 var toLocation = history.location; // TODO: We could probably make this more reliable by 1035 // keeping a list of paths we've seen in sessionStorage. 1036 // Instead, we just default to 0 for paths we don't know. 1037 1038 var toIndex = allPaths.lastIndexOf(createPath(toLocation)); 1039 if (toIndex === -1) toIndex = 0; 1040 var fromIndex = allPaths.lastIndexOf(createPath(fromLocation)); 1041 if (fromIndex === -1) fromIndex = 0; 1042 var delta = toIndex - fromIndex; 1043 1044 if (delta) { 1045 forceNextPop = true; 1046 go(delta); 1047 } 1048 } // Ensure the hash is encoded properly before doing anything else. 1049 1050 1051 var path = getHashPath(); 1052 var encodedPath = encodePath(path); 1053 if (path !== encodedPath) replaceHashPath(encodedPath); 1054 var initialLocation = getDOMLocation(); 1055 var allPaths = [createPath(initialLocation)]; // Public interface 1056 1057 function createHref(location) { 1058 var baseTag = document.querySelector('base'); 1059 var href = ''; 1060 1061 if (baseTag && baseTag.getAttribute('href')) { 1062 href = stripHash(window.location.href); 1063 } 1064 1065 return href + '#' + encodePath(basename + createPath(location)); 1066 } 1067 1068 function push(path, state) { 1069 false ? 0 : void 0; 1070 var action = 'PUSH'; 1071 var location = createLocation(path, undefined, undefined, history.location); 1072 transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { 1073 if (!ok) return; 1074 var path = createPath(location); 1075 var encodedPath = encodePath(basename + path); 1076 var hashChanged = getHashPath() !== encodedPath; 1077 1078 if (hashChanged) { 1079 // We cannot tell if a hashchange was caused by a PUSH, so we'd 1080 // rather setState here and ignore the hashchange. The caveat here 1081 // is that other hash histories in the page will consider it a POP. 1082 ignorePath = path; 1083 pushHashPath(encodedPath); 1084 var prevIndex = allPaths.lastIndexOf(createPath(history.location)); 1085 var nextPaths = allPaths.slice(0, prevIndex + 1); 1086 nextPaths.push(path); 1087 allPaths = nextPaths; 1088 setState({ 1089 action: action, 1090 location: location 1091 }); 1092 } else { 1093 false ? 0 : void 0; 1094 setState(); 1095 } 1096 }); 1097 } 1098 1099 function replace(path, state) { 1100 false ? 0 : void 0; 1101 var action = 'REPLACE'; 1102 var location = createLocation(path, undefined, undefined, history.location); 1103 transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { 1104 if (!ok) return; 1105 var path = createPath(location); 1106 var encodedPath = encodePath(basename + path); 1107 var hashChanged = getHashPath() !== encodedPath; 1108 1109 if (hashChanged) { 1110 // We cannot tell if a hashchange was caused by a REPLACE, so we'd 1111 // rather setState here and ignore the hashchange. The caveat here 1112 // is that other hash histories in the page will consider it a POP. 1113 ignorePath = path; 1114 replaceHashPath(encodedPath); 1115 } 1116 1117 var prevIndex = allPaths.indexOf(createPath(history.location)); 1118 if (prevIndex !== -1) allPaths[prevIndex] = path; 1119 setState({ 1120 action: action, 1121 location: location 1122 }); 1123 }); 1124 } 1125 1126 function go(n) { 1127 false ? 0 : void 0; 1128 globalHistory.go(n); 1129 } 1130 1131 function goBack() { 1132 go(-1); 1133 } 1134 1135 function goForward() { 1136 go(1); 1137 } 1138 1139 var listenerCount = 0; 1140 1141 function checkDOMListeners(delta) { 1142 listenerCount += delta; 1143 1144 if (listenerCount === 1 && delta === 1) { 1145 window.addEventListener(HashChangeEvent$1, handleHashChange); 1146 } else if (listenerCount === 0) { 1147 window.removeEventListener(HashChangeEvent$1, handleHashChange); 1148 } 1149 } 1150 1151 var isBlocked = false;
1152 1153 function block(prompt) { 1154 if (prompt === void 0) { 1155 prompt = false; 1156 } 1157 1158 var unblock = transitionManager.setPrompt(prompt); 1159 1160 if (!isBlocked) { 1161 checkDOMListeners(1); 1162 isBlocked = true; 1163 } 1164 1165 return function () { 1166 if (isBlocked) { 1167 isBlocked = false; 1168 checkDOMListeners(-1); 1169 } 1170 1171 return unblock(); 1172 }; 1173 } 1174 1175 function listen(listener) { 1176 var unlisten = transitionManager.appendListener(listener); 1177 checkDOMListeners(1); 1178 return function () { 1179 checkDOMListeners(-1); 1180 unlisten(); 1181 }; 1182 } 1183 1184 var history = { 1185 length: globalHistory.length, 1186 action: 'POP', 1187 location: initialLocation, 1188 createHref: createHref, 1189 push: push, 1190 replace: replace, 1191 go: go, 1192 goBack: goBack, 1193 goForward: goForward, 1194 block: block, 1195 listen: listen 1196 }; 1197 return history; 1198} 1199 1200function clamp(n, lowerBound, upperBound) { 1201 return Math.min(Math.max(n, lowerBound), upperBound); 1202} 1203/** 1204 * Creates a history object that stores locations in memory. 1205 */ 1206 1207 1208function createMemoryHistory(props) { 1209 if (props === void 0) { 1210 props = {}; 1211 } 1212 1213 var _props = props, 1214 getUserConfirmation = _props.getUserConfirmation, 1215 _props$initialEntries = _props.initialEntries, 1216 initialEntries = _props$initialEntries === void 0 ? ['/'] : _props$initialEntries, 1217 _props$initialIndex = _props.initialIndex, 1218 initialIndex = _props$initialIndex === void 0 ? 0 : _props$initialIndex, 1219 _props$keyLength = _props.keyLength, 1220 keyLength = _props$keyLength === void 0 ? 6 : _props$keyLength; 1221 var transitionManager = createTransitionManager(); 1222 1223 function setState(nextState) { 1224 (0,esm_extends/* default */.A)(history, nextState); 1225 1226 history.length = history.entries.length; 1227 transitionManager.notifyListeners(history.location, history.action); 1228 } 1229 1230 function createKey() { 1231 return Math.random().toString(36).substr(2, keyLength); 1232 } 1233 1234 var index = clamp(initialIndex, 0, initialEntries.length - 1); 1235 var entries = initialEntries.map(function (entry) { 1236 return typeof entry === 'string' ? createLocation(entry, undefined, createKey()) : createLocation(entry, undefined, entry.key || createKey()); 1237 }); // Public interface 1238 1239 var createHref = createPath; 1240 1241 function push(path, state) { 1242 false ? 0 : void 0; 1243 var action = 'PUSH'; 1244 var location = createLocation(path, state, createKey(), history.location); 1245 transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { 1246 if (!ok) return; 1247 var prevIndex = history.index; 1248 var nextIndex = prevIndex + 1; 1249 var nextEntries = history.entries.slice(0); 1250 1251 if (nextEntries.length > nextIndex) { 1252 nextEntries.splice(nextIndex, nextEntries.length - nextIndex, location); 1253 } else { 1254 nextEntries.push(location); 1255 } 1256 1257 setState({ 1258 action: action, 1259 location: location, 1260 index: nextIndex, 1261 entries: nextEntries 1262 }); 1263 }); 1264 } 1265 1266 function replace(path, state) { 1267 false ? 0 : void 0; 1268 var action = 'REPLACE'; 1269 var location = createLocation(path, state, createKey(), history.location); 1270 transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { 1271 if (!ok) return; 1272 history.entries[history.index] = location; 1273 setState({ 1274 action: action, 1275 location: location 1276 }); 1277 }); 1278 } 1279 1280 function go(n) { 1281 var nextIndex = clamp(history.index + n, 0, history.entries.length - 1); 1282 var action = 'POP'; 1283 var location = history.entries[nextIndex]; 1284 transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { 1285 if (ok) { 1286 setState({ 1287 action: action, 1288 location: location, 1289 index: nextIndex 1290 }); 1291 } else { 1292 // Mimic the behavior of DOM histories by 1293 // causing a render after a cancelled POP. 1294 setState(); 1295 } 1296 }); 1297 } 1298 1299 function goBack() { 1300 go(-1); 1301 } 1302 1303 function goForward() { 1304 go(1); 1305 } 1306 1307 function canGo(n) { 1308 var nextIndex = history.index + n; 1309 return nextIndex >= 0 && nextIndex < history.entries.length; 1310 } 1311 1312 function block(prompt) { 1313 if (prompt === void 0) { 1314 prompt = false;
1315 } 1316 1317 return transitionManager.setPrompt(prompt); 1318 } 1319 1320 function listen(listener) { 1321 return transitionManager.appendListener(listener); 1322 } 1323 1324 var history = { 1325 length: entries.length, 1326 action: 'POP', 1327 location: entries[index], 1328 index: index, 1329 entries: entries, 1330 createHref: createHref, 1331 push: push, 1332 replace: replace, 1333 go: go, 1334 goBack: goBack, 1335 goForward: goForward, 1336 canGo: canGo, 1337 block: block, 1338 listen: listen 1339 }; 1340 return history; 1341} 1342 1343 1344 1345 1346/***/ }), 1347 1348/***/ 2964: 1349/***/ ((module) => { 1350 1351module.exports = Array.isArray || function (arr) { 1352 return Object.prototype.toString.call(arr) == '[object Array]'; 1353}; 1354 1355 1356/***/ }), 1357 1358/***/ 6964: 1359/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1360 1361var isarray = __webpack_require__(2964) 1362 1363/** 1364 * Expose `pathToRegexp`. 1365 */ 1366module.exports = pathToRegexp 1367module.exports.parse = parse 1368module.exports.compile = compile 1369module.exports.tokensToFunction = tokensToFunction 1370module.exports.tokensToRegExp = tokensToRegExp 1371 1372/** 1373 * The main path matching regexp utility. 1374 * 1375 * @type {RegExp} 1376 */ 1377var PATH_REGEXP = new RegExp([ 1378 // Match escaped characters that would otherwise appear in future matches. 1379 // This allows the user to escape special characters that won't transform. 1380 '(\\\\.)', 1381 // Match Express-style parameters and un-named parameters with a prefix 1382 // and optional suffixes. Matches appear as: 1383 // 1384 // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined] 1385 // "/route(\\d+)" => [undefined, undefined, undefined, "\d+", undefined, undefined] 1386 // "/*" => ["/", undefined, undefined, undefined, undefined, "*"] 1387 '([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))' 1388].join('|'), 'g') 1389 1390/** 1391 * Parse a string for the raw tokens. 1392 * 1393 * @param {string} str 1394 * @param {Object=} options 1395 * @return {!Array} 1396 */ 1397function parse (str, options) { 1398 var tokens = [] 1399 var key = 0 1400 var index = 0 1401 var path = '' 1402 var defaultDelimiter = options && options.delimiter || '/' 1403 var res 1404 1405 while ((res = PATH_REGEXP.exec(str)) != null) { 1406 var m = res[0] 1407 var escaped = res[1] 1408 var offset = res.index 1409 path += str.slice(index, offset) 1410 index = offset + m.length 1411 1412 // Ignore already escaped sequences. 1413 if (escaped) { 1414 path += escaped[1] 1415 continue 1416 } 1417 1418 var next = str[index] 1419 var prefix = res[2] 1420 var name = res[3] 1421 var capture = res[4] 1422 var group = res[5] 1423 var modifier = res[6] 1424 var asterisk = res[7] 1425 1426 // Push the current path onto the tokens. 1427 if (path) { 1428 tokens.push(path) 1429 path = '' 1430 } 1431 1432 var partial = prefix != null && next != null && next !== prefix 1433 var repeat = modifier === '+' || modifier === '*' 1434 var optional = modifier === '?' || modifier === '*' 1435 var delimiter = prefix || defaultDelimiter 1436 var pattern = capture || group 1437 var prevText = prefix || (typeof tokens[tokens.length - 1] === 'string' ? tokens[tokens.length - 1] : '') 1438 1439 tokens.push({ 1440 name: name || key++, 1441 prefix: prefix || '', 1442 delimiter: delimiter, 1443 optional: optional, 1444 repeat: repeat, 1445 partial: partial, 1446 asterisk: !!asterisk, 1447 pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : restrictBacktrack(delimiter, prevText)) 1448 }) 1449 } 1450 1451 // Match any characters still remaining. 1452 if (index < str.length) { 1453 path += str.substr(index) 1454 } 1455 1456 // If the path exists, push it onto the end. 1457 if (path) { 1458 tokens.push(path) 1459 } 1460 1461 return tokens 1462} 1463 1464function restrictBacktrack(delimiter, prevText) { 1465 if (!prevText || prevText.indexOf(delimiter) > -1) { 1466 return '[^' + escapeString(delimiter) + ']+?' 1467 } 1468 1469 return escapeString(prevText) + '|(?:(?!' + escapeString(prevText) + ')[^' + escapeString(delimiter) + '])+?' 1470} 1471 1472/** 1473 * Compile a string to a template function for the path. 1474 * 1475 * @param {string} str 1476 * @param {Object=} options 1477 * @return {!function(Object=, Object=)} 1478 */ 1479function compile (str, options) { 1480 return tokensToFunction(parse(str, options), options) 1481} 1482 1483/** 1484 * Prettier encoding of URI path segments. 1485 * 1486 * @param {string} 1487 * @return {string} 1488 */ 1489function encodeURIComponentPretty (str) { 1490 return encodeURI(str).replace(/[\/?#]/g, function (c) {
1491 return '%' + c.charCodeAt(0).toString(16).toUpperCase() 1492 }) 1493} 1494 1495/** 1496 * Encode the asterisk parameter. Similar to `pretty`, but allows slashes. 1497 * 1498 * @param {string} 1499 * @return {string} 1500 */ 1501function encodeAsterisk (str) { 1502 return encodeURI(str).replace(/[?#]/g, function (c) { 1503 return '%' + c.charCodeAt(0).toString(16).toUpperCase() 1504 }) 1505} 1506 1507/** 1508 * Expose a method for transforming tokens into the path function. 1509 */ 1510function tokensToFunction (tokens, options) { 1511 // Compile all the tokens into regexps. 1512 var matches = new Array(tokens.length) 1513 1514 // Compile all the patterns before compilation. 1515 for (var i = 0; i < tokens.length; i++) { 1516 if (typeof tokens[i] === 'object') { 1517 matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$', flags(options)) 1518 } 1519 } 1520 1521 return function (obj, opts) { 1522 var path = '' 1523 var data = obj || {} 1524 var options = opts || {} 1525 var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent 1526 1527 for (var i = 0; i < tokens.length; i++) { 1528 var token = tokens[i] 1529 1530 if (typeof token === 'string') { 1531 path += token 1532 1533 continue 1534 } 1535 1536 var value = data[token.name] 1537 var segment 1538 1539 if (value == null) { 1540 if (token.optional) { 1541 // Prepend partial segment prefixes. 1542 if (token.partial) { 1543 path += token.prefix 1544 } 1545 1546 continue 1547 } else { 1548 throw new TypeError('Expected "' + token.name + '" to be defined') 1549 } 1550 } 1551 1552 if (isarray(value)) { 1553 if (!token.repeat) { 1554 throw new TypeError('Expected "' + token.name + '" to not repeat, but received `' + JSON.stringify(value) + '`') 1555 } 1556 1557 if (value.length === 0) { 1558 if (token.optional) { 1559 continue 1560 } else { 1561 throw new TypeError('Expected "' + token.name + '" to not be empty') 1562 } 1563 } 1564 1565 for (var j = 0; j < value.length; j++) { 1566 segment = encode(value[j]) 1567 1568 if (!matches[i].test(segment)) { 1569 throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + JSON.stringify(segment) + '`') 1570 } 1571 1572 path += (j === 0 ? token.prefix : token.delimiter) + segment 1573 } 1574 1575 continue 1576 } 1577 1578 segment = token.asterisk ? encodeAsterisk(value) : encode(value) 1579 1580 if (!matches[i].test(segment)) { 1581 throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"') 1582 } 1583 1584 path += token.prefix + segment 1585 } 1586 1587 return path 1588 } 1589} 1590 1591/** 1592 * Escape a regular expression string. 1593 * 1594 * @param {string} str 1595 * @return {string} 1596 */ 1597function escapeString (str) { 1598 return str.replace(/([.+*?=^!:${}()[\]|\/\\])/g, '\\$1') 1599} 1600 1601/** 1602 * Escape the capturing group by escaping special characters and meaning. 1603 * 1604 * @param {string} group 1605 * @return {string} 1606 */ 1607function escapeGroup (group) { 1608 return group.replace(/([=!:$\/()])/g, '\\$1') 1609} 1610 1611/** 1612 * Attach the keys as a property of the regexp. 1613 * 1614 * @param {!RegExp} re 1615 * @param {Array} keys 1616 * @return {!RegExp} 1617 */ 1618function attachKeys (re, keys) { 1619 re.keys = keys 1620 return re 1621} 1622 1623/** 1624 * Get the flags for a regexp from the options. 1625 * 1626 * @param {Object} options 1627 * @return {string} 1628 */ 1629function flags (options) { 1630 return options && options.sensitive ? '' : 'i' 1631} 1632 1633/** 1634 * Pull out keys from a regexp. 1635 * 1636 * @param {!RegExp} path 1637 * @param {!Array} keys 1638 * @return {!RegExp} 1639 */ 1640function regexpToRegexp (path, keys) { 1641 // Use a negative lookahead to match only capturing groups. 1642 var groups = path.source.match(/\((?!\?)/g) 1643 1644 if (groups) { 1645 for (var i = 0; i < groups.length; i++) { 1646 keys.push({ 1647 name: i, 1648 prefix: null, 1649 delimiter: null, 1650 optional: false, 1651 repeat: false, 1652 partial: false, 1653 asterisk: false, 1654 pattern: null 1655 }) 1656 } 1657 } 1658 1659 return attachKeys(path, keys) 1660} 1661 1662/** 1663 * Transform an array into a regexp. 1664 * 1665 * @param {!Array} path 1666 * @param {Array} keys 1667 * @param {!Object} options 1668 * @return {!RegExp} 1669 */ 1670function arrayToRegexp (path, keys, options) { 1671 var parts = [] 1672 1673 for (var i = 0; i < path.length; i++) { 1674 parts.push(pathToRegexp(path[i], keys, options).source) 1675 } 1676 1677 var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options)) 1678 1679 return attachKeys(regexp, keys) 1680} 1681 1682/** 1683 * Create a path regexp from string input. 1684 * 1685 * @param {string} path 1686 * @param {!Array} keys 1687 * @param {!Object} options 1688 * @return {!RegExp} 1689 */ 1690function stringToRegexp (path, keys, options) { 1691 return tokensToRegExp(parse(path, options), keys, options) 1692} 1693 1694/** 1695 * Expose a function for taking tokens and returning a RegExp. 1696 * 1697 * @param {!Array} tokens 1698 * @param {(Array|Object)=} keys 1699 * @param {Object=} options 1700 * @return {!RegExp} 1701 */ 1702function tokensToRegExp (tokens, keys, options) { 1703 if (!isarray(keys)) {
1704 options = /** @type {!Object} */ (keys || options) 1705 keys = [] 1706 } 1707 1708 options = options || {} 1709 1710 var strict = options.strict 1711 var end = options.end !== false 1712 var route = '' 1713 1714 // Iterate over the tokens and create our regexp string. 1715 for (var i = 0; i < tokens.length; i++) { 1716 var token = tokens[i] 1717 1718 if (typeof token === 'string') { 1719 route += escapeString(token) 1720 } else { 1721 var prefix = escapeString(token.prefix) 1722 var capture = '(?:' + token.pattern + ')' 1723 1724 keys.push(token) 1725 1726 if (token.repeat) { 1727 capture += '(?:' + prefix + capture + ')*' 1728 } 1729 1730 if (token.optional) { 1731 if (!token.partial) { 1732 capture = '(?:' + prefix + '(' + capture + '))?' 1733 } else { 1734 capture = prefix + '(' + capture + ')?' 1735 } 1736 } else { 1737 capture = prefix + '(' + capture + ')' 1738 } 1739 1740 route += capture 1741 } 1742 } 1743 1744 var delimiter = escapeString(options.delimiter || '/') 1745 var endsWithDelimiter = route.slice(-delimiter.length) === delimiter 1746 1747 // In non-strict mode we allow a slash at the end of match. If the path to 1748 // match already ends with a slash, we remove it for consistency. The slash 1749 // is valid at the end of a path match, not in the middle. This is important 1750 // in non-ending mode, where "/test/" shouldn't match "/test//route". 1751 if (!strict) { 1752 route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?' 1753 } 1754 1755 if (end) { 1756 route += '$' 1757 } else { 1758 // In non-ending mode, we need the capturing groups to match as much as 1759 // possible by using a positive lookahead to the end or next path segment. 1760 route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)' 1761 } 1762 1763 return attachKeys(new RegExp('^' + route, flags(options)), keys) 1764} 1765 1766/** 1767 * Normalize the given path string, returning a regular expression. 1768 * 1769 * An empty array can be passed in for the keys, which will hold the 1770 * placeholder key descriptions. For example, using `/user/:id`, `keys` will 1771 * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`. 1772 * 1773 * @param {(string|RegExp|Array)} path 1774 * @param {(Array|Object)=} keys 1775 * @param {Object=} options 1776 * @return {!RegExp} 1777 */ 1778function pathToRegexp (path, keys, options) { 1779 if (!isarray(keys)) {
1780 options = /** @type {!Object} */ (keys || options) 1781 keys = [] 1782 } 1783 1784 options = options || {} 1785 1786 if (path instanceof RegExp) { 1787 return regexpToRegexp(path, /** @type {!Array} */ (keys)) 1788 } 1789 1790 if (isarray(path)) { 1791 return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options) 1792 } 1793 1794 return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options) 1795} 1796 1797 1798/***/ }), 1799 1800/***/ 8925: 1801/***/ ((__unused_webpack_module, exports) => { 1802 1803"use strict"; 1804var __webpack_unused_export__; 1805/** @license React v16.13.1 1806 * react-is.production.min.js 1807 * 1808 * Copyright (c) Facebook, Inc. and its affiliates. 1809 * 1810 * This source code is licensed under the MIT license found in the 1811 * LICENSE file in the root directory of this source tree. 1812 */ 1813 1814var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b? 1815Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119; 1816function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}__webpack_unused_export__=l;__webpack_unused_export__=m;__webpack_unused_export__=k;__webpack_unused_export__=h;__webpack_unused_export__=c;__webpack_unused_export__=n;__webpack_unused_export__=e;__webpack_unused_export__=t;__webpack_unused_export__=r;__webpack_unused_export__=d; 1817__webpack_unused_export__=g;__webpack_unused_export__=f;__webpack_unused_export__=p;__webpack_unused_export__=function(a){return A(a)||z(a)===l};__webpack_unused_export__=A;__webpack_unused_export__=function(a){return z(a)===k};__webpack_unused_export__=function(a){return z(a)===h};__webpack_unused_export__=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===c};__webpack_unused_export__=function(a){return z(a)===n};__webpack_unused_export__=function(a){return z(a)===e};__webpack_unused_export__=function(a){return z(a)===t}; 1818__webpack_unused_export__=function(a){return z(a)===r};__webpack_unused_export__=function(a){return z(a)===d};__webpack_unused_export__=function(a){return z(a)===g};__webpack_unused_export__=function(a){return z(a)===f};__webpack_unused_export__=function(a){return z(a)===p}; 1819__webpack_unused_export__=function(a){return"string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};__webpack_unused_export__=z; 1820 1821 1822/***/ }), 1823 1824/***/ 4225: 1825/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 1826 1827"use strict"; 1828 1829 1830if (true) { 1831 /* unused reexport */ __webpack_require__(8925); 1832} else {} 1833 1834 1835/***/ }), 1836 1837/***/ 3205: 1838/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 1839 1840"use strict"; 1841/* harmony export */ __webpack_require__.d(__webpack_exports__, { 1842/* harmony export */ B6: () => (/* binding */ matchPath), 1843/* harmony export */ Ix: () => (/* binding */ Router), 1844/* harmony export */ W6: () => (/* binding */ useHistory), 1845/* harmony export */ XZ: () => (/* binding */ context), 1846/* harmony export */ dO: () => (/* binding */ Switch), 1847/* harmony export */ qh: () => (/* binding */ Route), 1848/* harmony export */ rd: () => (/* binding */ Redirect), 1849/* harmony export */ zy: () => (/* binding */ useLocation) 1850/* harmony export */ }); 1851/* unused harmony exports MemoryRouter, Prompt, StaticRouter, __HistoryContext, generatePath, useParams, useRouteMatch, withRouter */ 1852/* harmony import */ var _babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(7387); 1853/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6540); 1854/* harmony import */ var prop_types__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(5556); 1855/* harmony import */ var prop_types__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(prop_types__WEBPACK_IMPORTED_MODULE_5__); 1856/* harmony import */ var history__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(5591); 1857/* harmony import */ var tiny_invariant__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(1561); 1858/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(8168); 1859/* harmony import */ var path_to_regexp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6964); 1860/* harmony import */ var path_to_regexp__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path_to_regexp__WEBPACK_IMPORTED_MODULE_1__); 1861/* harmony import */ var react_is__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4225); 1862/* harmony import */ var _babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(8587); 1863/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4146); 1864/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_3__); 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877var MAX_SIGNED_31_BIT_INT = 1073741823; 1878var commonjsGlobal = typeof globalThis !== "undefined" // 'global proper' 1879? // eslint-disable-next-line no-undef 1880globalThis : typeof window !== "undefined" ? window // Browser 1881: typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g // node.js 1882: {}; 1883 1884function getUniqueId() { 1885 var key = "__global_unique_id__"; 1886 return commonjsGlobal[key] = (commonjsGlobal[key] || 0) + 1; 1887} // Inlined Object.is polyfill. 1888// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is 1889 1890 1891function objectIs(x, y) { 1892 if (x === y) { 1893 return x !== 0 || 1 / x === 1 / y; 1894 } else { 1895 // eslint-disable-next-line no-self-compare 1896 return x !== x && y !== y; 1897 } 1898} 1899 1900function createEventEmitter(value) { 1901 var handlers = []; 1902 return { 1903 on: function on(handler) { 1904 handlers.push(handler); 1905 }, 1906 off: function off(handler) { 1907 handlers = handlers.filter(function (h) { 1908 return h !== handler; 1909 }); 1910 }, 1911 get: function get() { 1912 return value; 1913 }, 1914 set: function set(newValue, changedBits) { 1915 value = newValue;
1916 handlers.forEach(function (handler) { 1917 return handler(value, changedBits); 1918 }); 1919 } 1920 }; 1921} 1922 1923function onlyChild(children) { 1924 return Array.isArray(children) ? children[0] : children; 1925} 1926 1927function createReactContext(defaultValue, calculateChangedBits) { 1928 var _Provider$childContex, _Consumer$contextType; 1929 1930 var contextProp = "__create-react-context-" + getUniqueId() + "__"; 1931 1932 var Provider = /*#__PURE__*/function (_React$Component) { 1933 (0,_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(Provider, _React$Component); 1934 1935 function Provider() { 1936 var _this; 1937 1938 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 1939 args[_key] = arguments[_key]; 1940 } 1941 1942 _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this; 1943 _this.emitter = createEventEmitter(_this.props.value); 1944 return _this; 1945 } 1946 1947 var _proto = Provider.prototype; 1948 1949 _proto.getChildContext = function getChildContext() { 1950 var _ref; 1951 1952 return _ref = {}, _ref[contextProp] = this.emitter, _ref; 1953 }; 1954 1955 _proto.componentWillReceiveProps = function componentWillReceiveProps(nextProps) { 1956 if (this.props.value !== nextProps.value) { 1957 var oldValue = this.props.value; 1958 var newValue = nextProps.value; 1959 var changedBits; 1960 1961 if (objectIs(oldValue, newValue)) { 1962 changedBits = 0; // No change 1963 } else { 1964 changedBits = typeof calculateChangedBits === "function" ? calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT; 1965 1966 if (false) {} 1967 1968 changedBits |= 0; 1969 1970 if (changedBits !== 0) { 1971 this.emitter.set(nextProps.value, changedBits); 1972 } 1973 } 1974 } 1975 }; 1976 1977 _proto.render = function render() { 1978 return this.props.children; 1979 }; 1980 1981 return Provider; 1982 }(react__WEBPACK_IMPORTED_MODULE_0__.Component); 1983 1984 Provider.childContextTypes = (_Provider$childContex = {}, _Provider$childContex[contextProp] = (prop_types__WEBPACK_IMPORTED_MODULE_5___default().object).isRequired, _Provider$childContex); 1985 1986 var Consumer = /*#__PURE__*/function (_React$Component2) { 1987 (0,_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(Consumer, _React$Component2); 1988 1989 function Consumer() { 1990 var _this2; 1991 1992 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 1993 args[_key2] = arguments[_key2]; 1994 } 1995 1996 _this2 = _React$Component2.call.apply(_React$Component2, [this].concat(args)) || this; 1997 _this2.observedBits = void 0; 1998 _this2.state = { 1999 value: _this2.getValue() 2000 }; 2001 2002 _this2.onUpdate = function (newValue, changedBits) { 2003 var observedBits = _this2.observedBits | 0; 2004 2005 if ((observedBits & changedBits) !== 0) { 2006 _this2.setState({ 2007 value: _this2.getValue() 2008 }); 2009 } 2010 }; 2011 2012 return _this2; 2013 } 2014 2015 var _proto2 = Consumer.prototype; 2016 2017 _proto2.componentWillReceiveProps = function componentWillReceiveProps(nextProps) { 2018 var observedBits = nextProps.observedBits; 2019 this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT // Subscribe to all changes by default 2020 : observedBits; 2021 }; 2022 2023 _proto2.componentDidMount = function componentDidMount() { 2024 if (this.context[contextProp]) { 2025 this.context[contextProp].on(this.onUpdate); 2026 } 2027 2028 var observedBits = this.props.observedBits; 2029 this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT // Subscribe to all changes by default 2030 : observedBits; 2031 }; 2032 2033 _proto2.componentWillUnmount = function componentWillUnmount() { 2034 if (this.context[contextProp]) { 2035 this.context[contextProp].off(this.onUpdate); 2036 } 2037 }; 2038 2039 _proto2.getValue = function getValue() { 2040 if (this.context[contextProp]) { 2041 return this.context[contextProp].get(); 2042 } else { 2043 return defaultValue; 2044 } 2045 }; 2046 2047 _proto2.render = function render() { 2048 return onlyChild(this.props.children)(this.state.value); 2049 }; 2050 2051 return Consumer; 2052 }(react__WEBPACK_IMPORTED_MODULE_0__.Component); 2053 2054 Consumer.contextTypes = (_Consumer$contextType = {}, _Consumer$contextType[contextProp] = (prop_types__WEBPACK_IMPORTED_MODULE_5___default().object), _Consumer$contextType); 2055 return { 2056 Provider: Provider, 2057 Consumer: Consumer 2058 }; 2059} 2060 2061// MIT License 2062var createContext = react__WEBPACK_IMPORTED_MODULE_0__.createContext || createReactContext; 2063 2064// TODO: Replace with React.createContext once we can assume React 16+ 2065 2066var createNamedContext = function createNamedContext(name) { 2067 var context = createContext(); 2068 context.displayName = name; 2069 return context; 2070}; 2071 2072var historyContext = /*#__PURE__*/createNamedContext("Router-History"); 2073
2074var context = /*#__PURE__*/createNamedContext("Router"); 2075 2076/** 2077 * The public API for putting history on context. 2078 */ 2079 2080var Router = /*#__PURE__*/function (_React$Component) { 2081 (0,_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(Router, _React$Component); 2082 2083 Router.computeRootMatch = function computeRootMatch(pathname) { 2084 return { 2085 path: "/", 2086 url: "/", 2087 params: {}, 2088 isExact: pathname === "/" 2089 }; 2090 }; 2091 2092 function Router(props) { 2093 var _this; 2094 2095 _this = _React$Component.call(this, props) || this; 2096 _this.state = { 2097 location: props.history.location 2098 }; // This is a bit of a hack. We have to start listening for location 2099 // changes here in the constructor in case there are any <Redirect>s 2100 // on the initial render. If there are, they will replace/push when 2101 // they mount and since cDM fires in children before parents, we may 2102 // get a new location before the <Router> is mounted. 2103 2104 _this._isMounted = false; 2105 _this._pendingLocation = null; 2106 2107 if (!props.staticContext) { 2108 _this.unlisten = props.history.listen(function (location) { 2109 _this._pendingLocation = location; 2110 }); 2111 } 2112 2113 return _this; 2114 } 2115 2116 var _proto = Router.prototype; 2117 2118 _proto.componentDidMount = function componentDidMount() { 2119 var _this2 = this; 2120 2121 this._isMounted = true; 2122 2123 if (this.unlisten) { 2124 // Any pre-mount location changes have been captured at 2125 // this point, so unregister the listener. 2126 this.unlisten(); 2127 } 2128 2129 if (!this.props.staticContext) { 2130 this.unlisten = this.props.history.listen(function (location) { 2131 if (_this2._isMounted) { 2132 _this2.setState({ 2133 location: location 2134 }); 2135 } 2136 }); 2137 } 2138 2139 if (this._pendingLocation) { 2140 this.setState({ 2141 location: this._pendingLocation 2142 }); 2143 } 2144 }; 2145 2146 _proto.componentWillUnmount = function componentWillUnmount() { 2147 if (this.unlisten) { 2148 this.unlisten(); 2149 this._isMounted = false; 2150 this._pendingLocation = null; 2151 } 2152 }; 2153 2154 _proto.render = function render() { 2155 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(context.Provider, { 2156 value: { 2157 history: this.props.history, 2158 location: this.state.location, 2159 match: Router.computeRootMatch(this.state.location.pathname), 2160 staticContext: this.props.staticContext 2161 } 2162 }, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(historyContext.Provider, { 2163 children: this.props.children || null, 2164 value: this.props.history 2165 })); 2166 }; 2167 2168 return Router; 2169}(react__WEBPACK_IMPORTED_MODULE_0__.Component); 2170 2171if (false) {} 2172 2173/** 2174 * The public API for a <Router> that stores location in memory. 2175 */ 2176 2177var MemoryRouter = /*#__PURE__*/function (_React$Component) { 2178 (0,_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(MemoryRouter, _React$Component); 2179 2180 function MemoryRouter() { 2181 var _this; 2182 2183 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 2184 args[_key] = arguments[_key]; 2185 } 2186 2187 _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this; 2188 _this.history = (0,history__WEBPACK_IMPORTED_MODULE_6__/* .createMemoryHistory */ .sC)(_this.props); 2189 return _this; 2190 } 2191 2192 var _proto = MemoryRouter.prototype; 2193 2194 _proto.render = function render() { 2195 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(Router, { 2196 history: this.history, 2197 children: this.props.children 2198 }); 2199 }; 2200 2201 return MemoryRouter; 2202}(react__WEBPACK_IMPORTED_MODULE_0__.Component); 2203 2204if (false) {} 2205 2206var Lifecycle = /*#__PURE__*/function (_React$Component) { 2207 (0,_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(Lifecycle, _React$Component); 2208 2209 function Lifecycle() { 2210 return _React$Component.apply(this, arguments) || this; 2211 } 2212 2213 var _proto = Lifecycle.prototype; 2214 2215 _proto.componentDidMount = function componentDidMount() { 2216 if (this.props.onMount) this.props.onMount.call(this, this); 2217 }; 2218 2219 _proto.componentDidUpdate = function componentDidUpdate(prevProps) { 2220 if (this.props.onUpdate) this.props.onUpdate.call(this, this, prevProps); 2221 }; 2222 2223 _proto.componentWillUnmount = function componentWillUnmount() { 2224 if (this.props.onUnmount) this.props.onUnmount.call(this, this); 2225 }; 2226 2227 _proto.render = function render() { 2228 return null; 2229 }; 2230 2231 return Lifecycle; 2232}(react__WEBPACK_IMPORTED_MODULE_0__.Component); 2233 2234/** 2235 * The public API for prompting the user before navigating away from a screen. 2236 */ 2237 2238function Prompt(_ref) { 2239 var message = _ref.message, 2240 _ref$when = _ref.when, 2241 when = _ref$when === void 0 ? true : _ref$when; 2242 return /*#__PURE__*/React.createElement(context.Consumer, null, function (context) { 2243 !context ? false ? 0 : invariant(false) : void 0; 2244 if (!when || context.staticContext) return null; 2245 var method = context.history.block; 2246 return /*#__PURE__*/React.createElement(Lifecycle, { 2247 onMount: function onMount(self) { 2248 self.release = method(message); 2249 }, 2250 onUpdate: function onUpdate(self, prevProps) { 2251 if (prevProps.message !== message) { 2252 self.release(); 2253 self.release = method(message); 2254 } 2255 }, 2256 onUnmount: function onUnmount(self) { 2257 self.release(); 2258 }, 2259 message: message 2260 }); 2261 }); 2262} 2263 2264if (false) { var messageType; } 2265 2266var cache = {}; 2267var cacheLimit = 10000; 2268var cacheCount = 0; 2269 2270function compilePath(path) { 2271 if (cache[path]) return cache[path]; 2272 var generator = path_to_regexp__WEBPACK_IMPORTED_MODULE_1___default().compile(path); 2273 2274 if (cacheCount < cacheLimit) { 2275 cache[path] = generator; 2276 cacheCount++; 2277 } 2278 2279 return generator; 2280} 2281/** 2282 * Public API for generating a URL pathname from a path and parameters. 2283 */ 2284 2285 2286function generatePath(path, params) { 2287 if (path === void 0) { 2288 path = "/"; 2289 } 2290 2291 if (params === void 0) { 2292 params = {}; 2293 } 2294 2295 return path === "/" ? path : compilePath(path)(params, { 2296 pretty: true 2297 }); 2298} 2299 2300/** 2301 * The public API for navigating programmatically with a component. 2302 */ 2303 2304function Redirect(_ref) { 2305 var computedMatch = _ref.computedMatch, 2306 to = _ref.to, 2307 _ref$push = _ref.push, 2308 push = _ref$push === void 0 ? false : _ref$push; 2309 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(context.Consumer, null, function (context) { 2310 !context ? false ? 0 : (0,tiny_invariant__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .A)(false) : void 0; 2311 var history = context.history, 2312 staticContext = context.staticContext; 2313 var method = push ? history.push : history.replace; 2314 var location = (0,history__WEBPACK_IMPORTED_MODULE_6__/* .createLocation */ .yJ)(computedMatch ? typeof to === "string" ? generatePath(to, computedMatch.params) : (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)({}, to, { 2315 pathname: generatePath(to.pathname, computedMatch.params) 2316 }) : to); // When rendering in a static context, 2317 // set the new location immediately. 2318 2319 if (staticContext) { 2320 method(location); 2321 return null; 2322 } 2323 2324 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(Lifecycle, { 2325 onMount: function onMount() { 2326 method(location); 2327 }, 2328 onUpdate: function onUpdate(self, prevProps) { 2329 var prevLocation = (0,history__WEBPACK_IMPORTED_MODULE_6__/* .createLocation */ .yJ)(prevProps.to); 2330 2331 if (!(0,history__WEBPACK_IMPORTED_MODULE_6__/* .locationsAreEqual */ .Fu)(prevLocation, (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)({}, location, { 2332 key: prevLocation.key 2333 }))) { 2334 method(location); 2335 } 2336 }, 2337 to: to 2338 }); 2339 }); 2340} 2341 2342if (false) {} 2343 2344var cache$1 = {}; 2345var cacheLimit$1 = 10000; 2346var cacheCount$1 = 0; 2347 2348function compilePath$1(path, options) { 2349 var cacheKey = "" + options.end + options.strict + options.sensitive; 2350 var pathCache = cache$1[cacheKey] || (cache$1[cacheKey] = {}); 2351 if (pathCache[path]) return pathCache[path]; 2352 var keys = []; 2353 var regexp = path_to_regexp__WEBPACK_IMPORTED_MODULE_1___default()(path, keys, options); 2354 var result = { 2355 regexp: regexp, 2356 keys: keys 2357 }; 2358 2359 if (cacheCount$1 < cacheLimit$1) { 2360 pathCache[path] = result; 2361 cacheCount$1++; 2362 } 2363 2364 return result; 2365} 2366/** 2367 * Public API for matching a URL pathname to a path. 2368 */ 2369 2370 2371function matchPath(pathname, options) { 2372 if (options === void 0) { 2373 options = {}; 2374 } 2375 2376 if (typeof options === "string" || Array.isArray(options)) { 2377 options = { 2378 path: options 2379 }; 2380 } 2381 2382 var _options = options, 2383 path = _options.path, 2384 _options$exact = _options.exact, 2385 exact = _options$exact === void 0 ? false : _options$exact, 2386 _options$strict = _options.strict,
2387 strict = _options$strict === void 0 ? false : _options$strict, 2388 _options$sensitive = _options.sensitive, 2389 sensitive = _options$sensitive === void 0 ? false : _options$sensitive; 2390 var paths = [].concat(path); 2391 return paths.reduce(function (matched, path) { 2392 if (!path && path !== "") return null; 2393 if (matched) return matched; 2394 2395 var _compilePath = compilePath$1(path, { 2396 end: exact, 2397 strict: strict, 2398 sensitive: sensitive 2399 }), 2400 regexp = _compilePath.regexp, 2401 keys = _compilePath.keys; 2402 2403 var match = regexp.exec(pathname); 2404 if (!match) return null; 2405 var url = match[0], 2406 values = match.slice(1); 2407 var isExact = pathname === url; 2408 if (exact && !isExact) return null; 2409 return { 2410 path: path, 2411 // the path used to match 2412 url: path === "/" && url === "" ? "/" : url, 2413 // the matched portion of the URL 2414 isExact: isExact, 2415 // whether or not we matched exactly 2416 params: keys.reduce(function (memo, key, index) { 2417 memo[key.name] = values[index]; 2418 return memo; 2419 }, {}) 2420 }; 2421 }, null); 2422} 2423 2424function isEmptyChildren(children) { 2425 return react__WEBPACK_IMPORTED_MODULE_0__.Children.count(children) === 0; 2426} 2427 2428function evalChildrenDev(children, props, path) { 2429 var value = children(props); 2430 false ? 0 : void 0; 2431 return value || null; 2432} 2433/** 2434 * The public API for matching a single path and rendering. 2435 */ 2436 2437 2438var Route = /*#__PURE__*/function (_React$Component) { 2439 (0,_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(Route, _React$Component); 2440 2441 function Route() { 2442 return _React$Component.apply(this, arguments) || this; 2443 } 2444 2445 var _proto = Route.prototype; 2446 2447 _proto.render = function render() { 2448 var _this = this; 2449 2450 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(context.Consumer, null, function (context$1) { 2451 !context$1 ? false ? 0 : (0,tiny_invariant__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .A)(false) : void 0; 2452 var location = _this.props.location || context$1.location; 2453 var match = _this.props.computedMatch ? _this.props.computedMatch // <Switch> already computed the match for us 2454 : _this.props.path ? matchPath(location.pathname, _this.props) : context$1.match; 2455 2456 var props = (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)({}, context$1, { 2457 location: location, 2458 match: match 2459 }); 2460 2461 var _this$props = _this.props, 2462 children = _this$props.children, 2463 component = _this$props.component, 2464 render = _this$props.render; // Preact uses an empty array as children by 2465 // default, so use null if that's the case. 2466 2467 if (Array.isArray(children) && isEmptyChildren(children)) { 2468 children = null; 2469 } 2470 2471 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(context.Provider, { 2472 value: props 2473 }, props.match ? children ? typeof children === "function" ? false ? 0 : children(props) : children : component ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(component, props) : render ? render(props) : null : typeof children === "function" ? false ? 0 : children(props) : null); 2474 }); 2475 }; 2476 2477 return Route; 2478}(react__WEBPACK_IMPORTED_MODULE_0__.Component); 2479 2480if (false) {} 2481 2482function addLeadingSlash(path) { 2483 return path.charAt(0) === "/" ? path : "/" + path; 2484} 2485 2486function addBasename(basename, location) { 2487 if (!basename) return location; 2488 return (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)({}, location, { 2489 pathname: addLeadingSlash(basename) + location.pathname 2490 }); 2491} 2492 2493function stripBasename(basename, location) { 2494 if (!basename) return location; 2495 var base = addLeadingSlash(basename); 2496 if (location.pathname.indexOf(base) !== 0) return location; 2497 return (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)({}, location, { 2498 pathname: location.pathname.substr(base.length) 2499 }); 2500} 2501 2502function createURL(location) { 2503 return typeof location === "string" ? location : (0,history__WEBPACK_IMPORTED_MODULE_6__/* .createPath */ .AO)(location); 2504} 2505 2506function staticHandler(methodName) { 2507 return function () { 2508 false ? 0 : (0,tiny_invariant__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .A)(false) ; 2509 }; 2510} 2511 2512function noop() {} 2513/** 2514 * The public top-level API for a "static" <Router>, so-called because it 2515 * can't actually change the current location. Instead, it just records 2516 * location changes in a context object. Useful mainly in testing and 2517 * server-rendering scenarios. 2518 */ 2519 2520 2521var StaticRouter = /*#__PURE__*/function (_React$Component) { 2522 (0,_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(StaticRouter, _React$Component); 2523 2524 function StaticRouter() { 2525 var _this; 2526 2527 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 2528 args[_key] = arguments[_key]; 2529 } 2530 2531 _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this; 2532 2533 _this.handlePush = function (location) { 2534 return _this.navigateTo(location, "PUSH"); 2535 }; 2536 2537 _this.handleReplace = function (location) { 2538 return _this.navigateTo(location, "REPLACE"); 2539 }; 2540 2541 _this.handleListen = function () { 2542 return noop; 2543 }; 2544 2545 _this.handleBlock = function () { 2546 return noop; 2547 }; 2548 2549 return _this; 2550 } 2551 2552 var _proto = StaticRouter.prototype; 2553 2554 _proto.navigateTo = function navigateTo(location, action) { 2555 var _this$props = this.props, 2556 _this$props$basename = _this$props.basename, 2557 basename = _this$props$basename === void 0 ? "" : _this$props$basename, 2558 _this$props$context = _this$props.context, 2559 context = _this$props$context === void 0 ? {}
2559 : _this$props$context; 2560 context.action = action; 2561 context.location = addBasename(basename, (0,history__WEBPACK_IMPORTED_MODULE_6__/* .createLocation */ .yJ)(location)); 2562 context.url = createURL(context.location); 2563 }; 2564 2565 _proto.render = function render() { 2566 var _this$props2 = this.props, 2567 _this$props2$basename = _this$props2.basename, 2568 basename = _this$props2$basename === void 0 ? "" : _this$props2$basename, 2569 _this$props2$context = _this$props2.context, 2570 context = _this$props2$context === void 0 ? {} : _this$props2$context, 2571 _this$props2$location = _this$props2.location, 2572 location = _this$props2$location === void 0 ? "/" : _this$props2$location, 2573 rest = (0,_babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(_this$props2, ["basename", "context", "location"]); 2574 2575 var history = { 2576 createHref: function createHref(path) { 2577 return addLeadingSlash(basename + createURL(path)); 2578 }, 2579 action: "POP", 2580 location: stripBasename(basename, (0,history__WEBPACK_IMPORTED_MODULE_6__/* .createLocation */ .yJ)(location)), 2581 push: this.handlePush, 2582 replace: this.handleReplace, 2583 go: staticHandler("go"), 2584 goBack: staticHandler("goBack"), 2585 goForward: staticHandler("goForward"), 2586 listen: this.handleListen, 2587 block: this.handleBlock 2588 }; 2589 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(Router, (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)({}, rest, { 2590 history: history, 2591 staticContext: context 2592 })); 2593 }; 2594 2595 return StaticRouter; 2596}(react__WEBPACK_IMPORTED_MODULE_0__.Component); 2597 2598if (false) {} 2599 2600/** 2601 * The public API for rendering the first <Route> that matches. 2602 */ 2603 2604var Switch = /*#__PURE__*/function (_React$Component) { 2605 (0,_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(Switch, _React$Component); 2606 2607 function Switch() { 2608 return _React$Component.apply(this, arguments) || this; 2609 } 2610 2611 var _proto = Switch.prototype; 2612 2613 _proto.render = function render() { 2614 var _this = this; 2615 2616 return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(context.Consumer, null, function (context) { 2617 !context ? false ? 0 : (0,tiny_invariant__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .A)(false) : void 0; 2618 var location = _this.props.location || context.location; 2619 var element, match; // We use React.Children.forEach instead of React.Children.toArray().find() 2620 // here because toArray adds keys to all child elements and we do not want 2621 // to trigger an unmount/remount for two <Route>s that render the same 2622 // component at different URLs. 2623 2624 react__WEBPACK_IMPORTED_MODULE_0__.Children.forEach(_this.props.children, function (child) { 2625 if (match == null && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.isValidElement(child)) { 2626 element = child; 2627 var path = child.props.path || child.props.from; 2628 match = path ? matchPath(location.pathname, (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)({}, child.props, { 2629 path: path 2630 })) : context.match; 2631 } 2632 }); 2633 return match ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.cloneElement(element, { 2634 location: location, 2635 computedMatch: match 2636 }) : null; 2637 }); 2638 }; 2639 2640 return Switch; 2641}(react__WEBPACK_IMPORTED_MODULE_0__.Component); 2642 2643if (false) {} 2644 2645/** 2646 * A public higher-order component to access the imperative API 2647 */ 2648 2649function withRouter(Component) { 2650 var displayName = "withRouter(" + (Component.displayName || Component.name) + ")"; 2651 2652 var C = function C(props) { 2653 var wrappedComponentRef = props.wrappedComponentRef, 2654 remainingProps = _objectWithoutPropertiesLoose(props, ["wrappedComponentRef"]); 2655 2656 return /*#__PURE__*/React.createElement(context.Consumer, null, function (context) { 2657 !context ? false ? 0 : invariant(false) : void 0; 2658 return /*#__PURE__*/React.createElement(Component, _extends({}, remainingProps, context, { 2659 ref: wrappedComponentRef 2660 })); 2661 }); 2662 }; 2663 2664 C.displayName = displayName; 2665 C.WrappedComponent = Component; 2666 2667 if (false) {} 2668 2669 return hoistStatics(C, Component); 2670} 2671 2672var useContext = react__WEBPACK_IMPORTED_MODULE_0__.useContext; 2673function useHistory() { 2674 if (false) {} 2675 2676 return useContext(historyContext); 2677} 2678function useLocation() { 2679 if (false) {} 2680 2681 return useContext(context).location; 2682} 2683function useParams() { 2684 if (false) {} 2685 2686 var match = useContext(context).match; 2687 return match ? match.params : {}; 2688} 2689function useRouteMatch(path) { 2690 if (false) {} 2691 2692 var location = useLocation(); 2693 var match = useContext(context).match; 2694 return path ? matchPath(location.pathname, path) : match; 2695} 2696 2697if (false) { var secondaryBuildName, initialBuildName, buildNames, key, global$1; } 2698 2699 2700//# sourceMappingURL=react-router.js.map 2701 2702 2703/***/ }), 2704 2705/***/ 8293: 2706/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 2707 2708"use strict"; 2709 2710// EXPORTS 2711__webpack_require__.d(__webpack_exports__, { 2712 A: () => (/* binding */ esm_CSSTransition) 2713}); 2714 2715// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js 2716var esm_extends = __webpack_require__(8168); 2717// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js 2718var objectWithoutPropertiesLoose = __webpack_require__(8587); 2719// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js 2720var inheritsLoose = __webpack_require__(7387); 2721// EXTERNAL MODULE: ./node_modules/dom-helpers/esm/addClass.js + 1 modules 2722var esm_addClass = __webpack_require__(8493); 2723// EXTERNAL MODULE: ./node_modules/dom-helpers/esm/removeClass.js 2724var esm_removeClass = __webpack_require__(8995); 2725// EXTERNAL MODULE: ./node_modules/react/index.js 2726var react = __webpack_require__(6540); 2727// EXTERNAL MODULE: ./node_modules/react-dom/index.js 2728var react_dom = __webpack_require__(961); 2729;// ./node_modules/react-transition-group/esm/config.js 2730/* harmony default export */ const config = ({ 2731 disabled: false 2732}); 2733// EXTERNAL MODULE: ./node_modules/react-transition-group/esm/TransitionGroupContext.js 2734var TransitionGroupContext = __webpack_require__(7241); 2735;// ./node_modules/react-transition-group/esm/utils/reflow.js 2736var forceReflow = function forceReflow(node) { 2737 return node.scrollTop; 2738}; 2739;// ./node_modules/react-transition-group/esm/Transition.js 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749var UNMOUNTED = 'unmounted'; 2750var EXITED = 'exited'; 2751var ENTERING = 'entering'; 2752var ENTERED = 'entered'; 2753var EXITING = 'exiting'; 2754/** 2755 * The Transition component lets you describe a transition from one component 2756 * state to another _over time_ with a simple declarative API. Most commonly 2757 * it's used to animate the mounting and unmounting of a component, but can also 2758 * be used to describe in-place transition states as well. 2759 * 2760 * --- 2761 * 2762 * **Note**: `Transition` is a platform-agnostic base component. If you're using 2763 * transitions in CSS, you'll probably want to use 2764 * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition) 2765 * instead. It inherits all the features of `Transition`, but contains 2766 * additional features necessary to play nice with CSS transitions (hence the 2767 * name of the component). 2768 * 2769 * --- 2770 * 2771 * By default the `Transition` component does not alter the behavior of the 2772 * component it renders, it only tracks "enter" and "exit" states for the 2773 * components. It's up to you to give meaning and effect to those states. For 2774 * example we can add styles to a component when it enters or exits: 2775 * 2776 * ```jsx 2777 * import { Transition } from 'react-transition-group'; 2778 * 2779 * const duration = 300; 2780 * 2781 * const defaultStyle = { 2782 * transition: `opacity ${duration}ms ease-in-out`, 2783 * opacity: 0, 2784 * } 2785 * 2786 * const transitionStyles = { 2787 * entering: { opacity: 1 }, 2788 * entered: { opacity: 1 }, 2789 * exiting: { opacity: 0 }, 2790 * exited: { opacity: 0 }, 2791 * }; 2792 * 2793 * const Fade = ({ in: inProp }) => ( 2794 * <Transition in={inProp} timeout={duration}> 2795 * {state => ( 2796 * <div style={{ 2797 * ...defaultStyle, 2798 * ...transitionStyles[state] 2799 * }}> 2800 * I'm a fade Transition! 2801 * </div> 2802 * )} 2803 * </Transition> 2804 * ); 2805 * ``` 2806 * 2807 * There are 4 main states a Transition can be in: 2808 * - `'entering'` 2809 * - `'entered'` 2810 * - `'exiting'` 2811 * - `'exited'` 2812 * 2813 * Transition state is toggled via the `in` prop. When `true` the component 2814 * begins the "Enter" stage. During this stage, the component will shift from 2815 * its current transition state, to `'entering'` for the duration of the 2816 * transition and then to the `'entered'` stage once it's complete. Let's take 2817 * the following example (we'll use the 2818 * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook): 2819 * 2820 * ```jsx 2821 * function App() { 2822 * const [inProp, setInProp] = useState(false); 2823 * return ( 2824 * <div> 2825 * <Transition in={inProp} timeout={500}> 2826 * {state => ( 2827 * // ... 2828 * )} 2829 * </Transition> 2830 * <button onClick={() => setInProp(true)}> 2831 * Click to Enter 2832 * </button>
2833 * </div> 2834 * ); 2835 * } 2836 * ``` 2837 * 2838 * When the button is clicked the component will shift to the `'entering'` state 2839 * and stay there for 500ms (the value of `timeout`) before it finally switches 2840 * to `'entered'`. 2841 * 2842 * When `in` is `false` the same thing happens except the state moves from 2843 * `'exiting'` to `'exited'`. 2844 */ 2845 2846var Transition = /*#__PURE__*/function (_React$Component) { 2847 (0,inheritsLoose/* default */.A)(Transition, _React$Component); 2848 2849 function Transition(props, context) { 2850 var _this; 2851 2852 _this = _React$Component.call(this, props, context) || this; 2853 var parentGroup = context; // In the context of a TransitionGroup all enters are really appears 2854 2855 var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear; 2856 var initialStatus; 2857 _this.appearStatus = null; 2858 2859 if (props.in) { 2860 if (appear) { 2861 initialStatus = EXITED; 2862 _this.appearStatus = ENTERING; 2863 } else { 2864 initialStatus = ENTERED; 2865 } 2866 } else { 2867 if (props.unmountOnExit || props.mountOnEnter) { 2868 initialStatus = UNMOUNTED; 2869 } else { 2870 initialStatus = EXITED; 2871 } 2872 } 2873 2874 _this.state = { 2875 status: initialStatus 2876 }; 2877 _this.nextCallback = null; 2878 return _this; 2879 } 2880 2881 Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) { 2882 var nextIn = _ref.in; 2883 2884 if (nextIn && prevState.status === UNMOUNTED) { 2885 return { 2886 status: EXITED 2887 }; 2888 } 2889 2890 return null; 2891 } // getSnapshotBeforeUpdate(prevProps) { 2892 // let nextStatus = null 2893 // if (prevProps !== this.props) { 2894 // const { status } = this.state 2895 // if (this.props.in) { 2896 // if (status !== ENTERING && status !== ENTERED) { 2897 // nextStatus = ENTERING 2898 // } 2899 // } else { 2900 // if (status === ENTERING || status === ENTERED) { 2901 // nextStatus = EXITING 2902 // } 2903 // } 2904 // } 2905 // return { nextStatus } 2906 // } 2907 ; 2908 2909 var _proto = Transition.prototype; 2910 2911 _proto.componentDidMount = function componentDidMount() { 2912 this.updateStatus(true, this.appearStatus); 2913 }; 2914 2915 _proto.componentDidUpdate = function componentDidUpdate(prevProps) { 2916 var nextStatus = null; 2917 2918 if (prevProps !== this.props) { 2919 var status = this.state.status; 2920 2921 if (this.props.in) { 2922 if (status !== ENTERING && status !== ENTERED) { 2923 nextStatus = ENTERING; 2924 } 2925 } else { 2926 if (status === ENTERING || status === ENTERED) { 2927 nextStatus = EXITING; 2928 } 2929 } 2930 } 2931 2932 this.updateStatus(false, nextStatus); 2933 }; 2934 2935 _proto.componentWillUnmount = function componentWillUnmount() { 2936 this.cancelNextCallback(); 2937 }; 2938 2939 _proto.getTimeouts = function getTimeouts() { 2940 var timeout = this.props.timeout; 2941 var exit, enter, appear; 2942 exit = enter = appear = timeout; 2943 2944 if (timeout != null && typeof timeout !== 'number') { 2945 exit = timeout.exit; 2946 enter = timeout.enter; // TODO: remove fallback for next major 2947 2948 appear = timeout.appear !== undefined ? timeout.appear : enter; 2949 } 2950 2951 return { 2952 exit: exit, 2953 enter: enter, 2954 appear: appear 2955 }; 2956 }; 2957 2958 _proto.updateStatus = function updateStatus(mounting, nextStatus) { 2959 if (mounting === void 0) { 2960 mounting = false; 2961 } 2962 2963 if (nextStatus !== null) { 2964 // nextStatus will always be ENTERING or EXITING. 2965 this.cancelNextCallback(); 2966 2967 if (nextStatus === ENTERING) { 2968 if (this.props.unmountOnExit || this.props.mountOnEnter) { 2969 var node = this.props.nodeRef ? this.props.nodeRef.current : react_dom.findDOMNode(this); // https://github.com/reactjs/react-transition-group/pull/749
vendor: 5,992 bytes, lines 2970-3163
2970 // With unmountOnExit or mountOnEnter, the enter animation should happen at the transition between `exited` and `entering`. 2971 // To make the animation happen, we have to separate each rendering and avoid being processed as batched. 2972 2973 if (node) forceReflow(node); 2974 } 2975 2976 this.performEnter(mounting); 2977 } else { 2978 this.performExit(); 2979 } 2980 } else if (this.props.unmountOnExit && this.state.status === EXITED) { 2981 this.setState({ 2982 status: UNMOUNTED 2983 }); 2984 } 2985 }; 2986 2987 _proto.performEnter = function performEnter(mounting) { 2988 var _this2 = this; 2989 2990 var enter = this.props.enter; 2991 var appearing = this.context ? this.context.isMounting : mounting; 2992 2993 var _ref2 = this.props.nodeRef ? [appearing] : [react_dom.findDOMNode(this), appearing], 2994 maybeNode = _ref2[0], 2995 maybeAppearing = _ref2[1]; 2996 2997 var timeouts = this.getTimeouts(); 2998 var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED 2999 // if we are mounting and running this it means appear _must_ be set 3000 3001 if (!mounting && !enter || config.disabled) { 3002 this.safeSetState({ 3003 status: ENTERED 3004 }, function () { 3005 _this2.props.onEntered(maybeNode); 3006 }); 3007 return; 3008 } 3009 3010 this.props.onEnter(maybeNode, maybeAppearing); 3011 this.safeSetState({ 3012 status: ENTERING 3013 }, function () { 3014 _this2.props.onEntering(maybeNode, maybeAppearing); 3015 3016 _this2.onTransitionEnd(enterTimeout, function () { 3017 _this2.safeSetState({ 3018 status: ENTERED 3019 }, function () { 3020 _this2.props.onEntered(maybeNode, maybeAppearing); 3021 }); 3022 }); 3023 }); 3024 }; 3025 3026 _proto.performExit = function performExit() { 3027 var _this3 = this; 3028 3029 var exit = this.props.exit; 3030 var timeouts = this.getTimeouts(); 3031 var maybeNode = this.props.nodeRef ? undefined : react_dom.findDOMNode(this); // no exit animation skip right to EXITED 3032 3033 if (!exit || config.disabled) { 3034 this.safeSetState({ 3035 status: EXITED 3036 }, function () { 3037 _this3.props.onExited(maybeNode); 3038 }); 3039 return; 3040 } 3041 3042 this.props.onExit(maybeNode); 3043 this.safeSetState({ 3044 status: EXITING 3045 }, function () { 3046 _this3.props.onExiting(maybeNode); 3047 3048 _this3.onTransitionEnd(timeouts.exit, function () { 3049 _this3.safeSetState({ 3050 status: EXITED 3051 }, function () { 3052 _this3.props.onExited(maybeNode); 3053 }); 3054 }); 3055 }); 3056 }; 3057 3058 _proto.cancelNextCallback = function cancelNextCallback() { 3059 if (this.nextCallback !== null) { 3060 this.nextCallback.cancel(); 3061 this.nextCallback = null; 3062 } 3063 }; 3064 3065 _proto.safeSetState = function safeSetState(nextState, callback) { 3066 // This shouldn't be necessary, but there are weird race conditions with 3067 // setState callbacks and unmounting in testing, so always make sure that 3068 // we can cancel any pending setState callbacks after we unmount. 3069 callback = this.setNextCallback(callback); 3070 this.setState(nextState, callback); 3071 }; 3072 3073 _proto.setNextCallback = function setNextCallback(callback) { 3074 var _this4 = this; 3075 3076 var active = true; 3077 3078 this.nextCallback = function (event) { 3079 if (active) { 3080 active = false; 3081 _this4.nextCallback = null; 3082 callback(event); 3083 } 3084 }; 3085 3086 this.nextCallback.cancel = function () { 3087 active = false; 3088 }; 3089 3090 return this.nextCallback; 3091 }; 3092 3093 _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) { 3094 this.setNextCallback(handler); 3095 var node = this.props.nodeRef ? this.props.nodeRef.current : react_dom.findDOMNode(this); 3096 var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener; 3097 3098 if (!node || doesNotHaveTimeoutOrListener) { 3099 setTimeout(this.nextCallback, 0); 3100 return; 3101 } 3102 3103 if (this.props.addEndListener) { 3104 var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback], 3105 maybeNode = _ref3[0], 3106 maybeNextCallback = _ref3[1]; 3107 3108 this.props.addEndListener(maybeNode, maybeNextCallback); 3109 } 3110 3111 if (timeout != null) { 3112 setTimeout(this.nextCallback, timeout); 3113 } 3114 }; 3115 3116 _proto.render = function render() { 3117 var status = this.state.status; 3118 3119 if (status === UNMOUNTED) { 3120 return null; 3121 } 3122 3123 var _this$props = this.props, 3124 children = _this$props.children, 3125 _in = _this$props.in, 3126 _mountOnEnter = _this$props.mountOnEnter, 3127 _unmountOnExit = _this$props.unmountOnExit, 3128 _appear = _this$props.appear, 3129 _enter = _this$props.enter, 3130 _exit = _this$props.exit, 3131 _timeout = _this$props.timeout, 3132 _addEndListener = _this$props.addEndListener, 3133 _onEnter = _this$props.onEnter, 3134 _onEntering = _this$props.onEntering, 3135 _onEntered = _this$props.onEntered, 3136 _onExit = _this$props.onExit, 3137 _onExiting = _this$props.onExiting, 3138 _onExited = _this$props.onExited, 3139 _nodeRef = _this$props.nodeRef, 3140 childProps = (0,objectWithoutPropertiesLoose/* default */.A)(_this$props, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]); 3141 3142 return ( 3143 /*#__PURE__*/ 3144 // allows for nested Transitions 3145 react.createElement(TransitionGroupContext/* default */.A.Provider, { 3146 value: null 3147 }, typeof children === 'function' ? children(status, childProps) : react.cloneElement(react.Children.only(children), childProps)) 3148 ); 3149 }; 3150 3151 return Transition; 3152}(react.Component); 3153 3154Transition.contextType = TransitionGroupContext/* default */.A; 3155Transition.propTypes = false ? 0 : {}; // Name the function so it is clearer in the documentation 3156 3157function noop() {} 3158 3159Transition.defaultProps = { 3160 in: false, 3161 mountOnEnter: false, 3162 unmountOnExit: false, 3163 appear: false,
3164 enter: true, 3165 exit: true, 3166 onEnter: noop, 3167 onEntering: noop, 3168 onEntered: noop, 3169 onExit: noop, 3170 onExiting: noop, 3171 onExited: noop 3172}; 3173Transition.UNMOUNTED = UNMOUNTED; 3174Transition.EXITED = EXITED; 3175Transition.ENTERING = ENTERING; 3176Transition.ENTERED = ENTERED; 3177Transition.EXITING = EXITING; 3178/* harmony default export */ const esm_Transition = (Transition); 3179;// ./node_modules/react-transition-group/esm/CSSTransition.js 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191var _addClass = function addClass(node, classes) { 3192 return node && classes && classes.split(' ').forEach(function (c) { 3193 return (0,esm_addClass/* default */.A)(node, c); 3194 }); 3195}; 3196 3197var removeClass = function removeClass(node, classes) { 3198 return node && classes && classes.split(' ').forEach(function (c) { 3199 return (0,esm_removeClass/* default */.A)(node, c); 3200 }); 3201}; 3202/** 3203 * A transition component inspired by the excellent 3204 * [ng-animate](https://docs.angularjs.org/api/ngAnimate) library, you should 3205 * use it if you're using CSS transitions or animations. It's built upon the 3206 * [`Transition`](https://reactcommunity.org/react-transition-group/transition) 3207 * component, so it inherits all of its props. 3208 * 3209 * `CSSTransition` applies a pair of class names during the `appear`, `enter`, 3210 * and `exit` states of the transition. The first class is applied and then a 3211 * second `*-active` class in order to activate the CSS transition. After the 3212 * transition, matching `*-done` class names are applied to persist the 3213 * transition state. 3214 * 3215 * ```jsx 3216 * function App() { 3217 * const [inProp, setInProp] = useState(false); 3218 * return ( 3219 * <div> 3220 * <CSSTransition in={inProp} timeout={200} classNames="my-node"> 3221 * <div> 3222 * {"I'll receive my-node-* classes"} 3223 * </div> 3224 * </CSSTransition> 3225 * <button type="button" onClick={() => setInProp(true)}> 3226 * Click to Enter 3227 * </button> 3228 * </div> 3229 * ); 3230 * } 3231 * ``` 3232 * 3233 * When the `in` prop is set to `true`, the child component will first receive 3234 * the class `example-enter`, then the `example-enter-active` will be added in 3235 * the next tick. `CSSTransition` [forces a 3236 * reflow](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215) 3237 * between before adding the `example-enter-active`. This is an important trick 3238 * because it allows us to transition between `example-enter` and 3239 * `example-enter-active` even though they were added immediately one after 3240 * another. Most notably, this is what makes it possible for us to animate 3241 * _appearance_. 3242 * 3243 * ```css 3244 * .my-node-enter { 3245 * opacity: 0; 3246 * } 3247 * .my-node-enter-active { 3248 * opacity: 1; 3249 * transition: opacity 200ms; 3250 * } 3251 * .my-node-exit { 3252 * opacity: 1; 3253 * } 3254 * .my-node-exit-active { 3255 * opacity: 0; 3256 * transition: opacity 200ms; 3257 * } 3258 * ``` 3259 * 3260 * `*-active` classes represent which styles you want to animate **to**, so it's 3261 * important to add `transition` declaration only to them, otherwise transitions 3262 * might not behave as intended! This might not be obvious when the transitions
3263 * are symmetrical, i.e. when `*-enter-active` is the same as `*-exit`, like in 3264 * the example above (minus `transition`), but it becomes apparent in more 3265 * complex transitions. 3266 * 3267 * **Note**: If you're using the 3268 * [`appear`](http://reactcommunity.org/react-transition-group/transition#Transition-prop-appear) 3269 * prop, make sure to define styles for `.appear-*` classes as well. 3270 */ 3271 3272 3273var CSSTransition = /*#__PURE__*/function (_React$Component) { 3274 (0,inheritsLoose/* default */.A)(CSSTransition, _React$Component); 3275 3276 function CSSTransition() { 3277 var _this; 3278 3279 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 3280 args[_key] = arguments[_key]; 3281 } 3282 3283 _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this; 3284 _this.appliedClasses = { 3285 appear: {}, 3286 enter: {}, 3287 exit: {} 3288 }; 3289 3290 _this.onEnter = function (maybeNode, maybeAppearing) { 3291 var _this$resolveArgument = _this.resolveArguments(maybeNode, maybeAppearing), 3292 node = _this$resolveArgument[0], 3293 appearing = _this$resolveArgument[1]; 3294 3295 _this.removeClasses(node, 'exit'); 3296 3297 _this.addClass(node, appearing ? 'appear' : 'enter', 'base'); 3298 3299 if (_this.props.onEnter) { 3300 _this.props.onEnter(maybeNode, maybeAppearing); 3301 } 3302 }; 3303 3304 _this.onEntering = function (maybeNode, maybeAppearing) { 3305 var _this$resolveArgument2 = _this.resolveArguments(maybeNode, maybeAppearing), 3306 node = _this$resolveArgument2[0], 3307 appearing = _this$resolveArgument2[1]; 3308 3309 var type = appearing ? 'appear' : 'enter'; 3310 3311 _this.addClass(node, type, 'active'); 3312 3313 if (_this.props.onEntering) { 3314 _this.props.onEntering(maybeNode, maybeAppearing); 3315 } 3316 }; 3317 3318 _this.onEntered = function (maybeNode, maybeAppearing) { 3319 var _this$resolveArgument3 = _this.resolveArguments(maybeNode, maybeAppearing), 3320 node = _this$resolveArgument3[0], 3321 appearing = _this$resolveArgument3[1]; 3322 3323 var type = appearing ? 'appear' : 'enter'; 3324 3325 _this.removeClasses(node, type); 3326 3327 _this.addClass(node, type, 'done'); 3328 3329 if (_this.props.onEntered) { 3330 _this.props.onEntered(maybeNode, maybeAppearing); 3331 } 3332 }; 3333 3334 _this.onExit = function (maybeNode) { 3335 var _this$resolveArgument4 = _this.resolveArguments(maybeNode), 3336 node = _this$resolveArgument4[0]; 3337 3338 _this.removeClasses(node, 'appear'); 3339 3340 _this.removeClasses(node, 'enter'); 3341 3342 _this.addClass(node, 'exit', 'base'); 3343 3344 if (_this.props.onExit) { 3345 _this.props.onExit(maybeNode); 3346 } 3347 }; 3348 3349 _this.onExiting = function (maybeNode) { 3350 var _this$resolveArgument5 = _this.resolveArguments(maybeNode), 3351 node = _this$resolveArgument5[0]; 3352 3353 _this.addClass(node, 'exit', 'active'); 3354 3355 if (_this.props.onExiting) { 3356 _this.props.onExiting(maybeNode); 3357 } 3358 }; 3359 3360 _this.onExited = function (maybeNode) { 3361 var _this$resolveArgument6 = _this.resolveArguments(maybeNode), 3362 node = _this$resolveArgument6[0]; 3363 3364 _this.removeClasses(node, 'exit'); 3365 3366 _this.addClass(node, 'exit', 'done'); 3367 3368 if (_this.props.onExited) { 3369 _this.props.onExited(maybeNode); 3370 } 3371 }; 3372 3373 _this.resolveArguments = function (maybeNode, maybeAppearing) { 3374 return _this.props.nodeRef ? [_this.props.nodeRef.current, maybeNode] // here `maybeNode` is actually `appearing` 3375 : [maybeNode, maybeAppearing]; 3376 }; 3377 3378 _this.getClassNames = function (type) { 3379 var classNames = _this.props.classNames; 3380 var isStringClassNames = typeof classNames === 'string'; 3381 var prefix = isStringClassNames && classNames ? classNames + "-" : ''; 3382 var baseClassName = isStringClassNames ? "" + prefix + type : classNames[type]; 3383 var activeClassName = isStringClassNames ? baseClassName + "-active" : classNames[type + "Active"]; 3384 var doneClassName = isStringClassNames ? baseClassName + "-done" : classNames[type + "Done"]; 3385 return { 3386 baseClassName: baseClassName, 3387 activeClassName: activeClassName, 3388 doneClassName: doneClassName 3389 }; 3390 }; 3391 3392 return _this; 3393 } 3394 3395 var _proto = CSSTransition.prototype; 3396 3397 _proto.addClass = function addClass(node, type, phase) { 3398 var className = this.getClassNames(type)[phase + "ClassName"]; 3399 3400 var _this$getClassNames = this.getClassNames('enter'), 3401 doneClassName = _this$getClassNames.doneClassName; 3402 3403 if (type === 'appear' && phase === 'done' && doneClassName) { 3404 className += " " + doneClassName; 3405 } // This is to force a repaint, 3406 // which is necessary in order to transition styles when adding a class name. 3407 3408 3409 if (phase === 'active') { 3410 if (node) forceReflow(node); 3411 } 3412 3413 if (className) {
3414 this.appliedClasses[type][phase] = className; 3415 3416 _addClass(node, className); 3417 } 3418 }; 3419 3420 _proto.removeClasses = function removeClasses(node, type) { 3421 var _this$appliedClasses$ = this.appliedClasses[type], 3422 baseClassName = _this$appliedClasses$.base, 3423 activeClassName = _this$appliedClasses$.active, 3424 doneClassName = _this$appliedClasses$.done; 3425 this.appliedClasses[type] = {}; 3426 3427 if (baseClassName) { 3428 removeClass(node, baseClassName); 3429 } 3430 3431 if (activeClassName) { 3432 removeClass(node, activeClassName); 3433 } 3434 3435 if (doneClassName) { 3436 removeClass(node, doneClassName); 3437 } 3438 }; 3439 3440 _proto.render = function render() { 3441 var _this$props = this.props, 3442 _ = _this$props.classNames, 3443 props = (0,objectWithoutPropertiesLoose/* default */.A)(_this$props, ["classNames"]); 3444 3445 return /*#__PURE__*/react.createElement(esm_Transition, (0,esm_extends/* default */.A)({}, props, { 3446 onEnter: this.onEnter, 3447 onEntered: this.onEntered, 3448 onEntering: this.onEntering, 3449 onExit: this.onExit, 3450 onExiting: this.onExiting, 3451 onExited: this.onExited 3452 })); 3453 }; 3454 3455 return CSSTransition; 3456}(react.Component); 3457 3458CSSTransition.defaultProps = { 3459 classNames: '' 3460}; 3461CSSTransition.propTypes = false ? 0 : {}; 3462/* harmony default export */ const esm_CSSTransition = (CSSTransition); 3463 3464/***/ }), 3465 3466/***/ 2618: 3467/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 3468 3469"use strict"; 3470 3471// EXPORTS 3472__webpack_require__.d(__webpack_exports__, { 3473 A: () => (/* binding */ esm_TransitionGroup) 3474}); 3475 3476// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js 3477var objectWithoutPropertiesLoose = __webpack_require__(8587); 3478// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js 3479var esm_extends = __webpack_require__(8168); 3480// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js 3481var assertThisInitialized = __webpack_require__(9417); 3482// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js 3483var inheritsLoose = __webpack_require__(7387); 3484// EXTERNAL MODULE: ./node_modules/react/index.js 3485var react = __webpack_require__(6540); 3486// EXTERNAL MODULE: ./node_modules/react-transition-group/esm/TransitionGroupContext.js 3487var TransitionGroupContext = __webpack_require__(7241); 3488;// ./node_modules/react-transition-group/esm/utils/ChildMapping.js 3489 3490/** 3491 * Given `this.props.children`, return an object mapping key to child. 3492 * 3493 * @param {*} children `this.props.children` 3494 * @return {object} Mapping of key to child 3495 */ 3496 3497function getChildMapping(children, mapFn) { 3498 var mapper = function mapper(child) { 3499 return mapFn && (0,react.isValidElement)(child) ? mapFn(child) : child; 3500 }; 3501 3502 var result = Object.create(null); 3503 if (children) react.Children.map(children, function (c) { 3504 return c; 3505 }).forEach(function (child) { 3506 // run the map function here instead so that the key is the computed one 3507 result[child.key] = mapper(child); 3508 }); 3509 return result; 3510} 3511/** 3512 * When you're adding or removing children some may be added or removed in the 3513 * same render pass. We want to show *both* since we want to simultaneously 3514 * animate elements in and out. This function takes a previous set of keys 3515 * and a new set of keys and merges them with its best guess of the correct 3516 * ordering. In the future we may expose some of the utilities in 3517 * ReactMultiChild to make this easy, but for now React itself does not 3518 * directly have this concept of the union of prevChildren and nextChildren 3519 * so we implement it here. 3520 * 3521 * @param {object} prev prev children as returned from 3522 * `ReactTransitionChildMapping.getChildMapping()`. 3523 * @param {object} next next children as returned from 3524 * `ReactTransitionChildMapping.getChildMapping()`. 3525 * @return {object} a key set that contains all keys in `prev` and all keys 3526 * in `next` in a reasonable order. 3527 */ 3528 3529function mergeChildMappings(prev, next) { 3530 prev = prev || {}; 3531 next = next || {}; 3532 3533 function getValueForKey(key) { 3534 return key in next ? next[key] : prev[key]; 3535 } // For each key of `next`, the list of keys to insert before that key in 3536 // the combined list 3537 3538 3539 var nextKeysPending = Object.create(null);
vendor: 4,406 bytes, lines 3540-3681
3540 var pendingKeys = []; 3541 3542 for (var prevKey in prev) { 3543 if (prevKey in next) { 3544 if (pendingKeys.length) { 3545 nextKeysPending[prevKey] = pendingKeys; 3546 pendingKeys = []; 3547 } 3548 } else { 3549 pendingKeys.push(prevKey); 3550 } 3551 } 3552 3553 var i; 3554 var childMapping = {}; 3555 3556 for (var nextKey in next) { 3557 if (nextKeysPending[nextKey]) { 3558 for (i = 0; i < nextKeysPending[nextKey].length; i++) { 3559 var pendingNextKey = nextKeysPending[nextKey][i]; 3560 childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey); 3561 } 3562 } 3563 3564 childMapping[nextKey] = getValueForKey(nextKey); 3565 } // Finally, add the keys which didn't appear before any key in `next` 3566 3567 3568 for (i = 0; i < pendingKeys.length; i++) { 3569 childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]); 3570 } 3571 3572 return childMapping; 3573} 3574 3575function getProp(child, prop, props) { 3576 return props[prop] != null ? props[prop] : child.props[prop]; 3577} 3578 3579function getInitialChildMapping(props, onExited) { 3580 return getChildMapping(props.children, function (child) { 3581 return (0,react.cloneElement)(child, { 3582 onExited: onExited.bind(null, child), 3583 in: true, 3584 appear: getProp(child, 'appear', props), 3585 enter: getProp(child, 'enter', props), 3586 exit: getProp(child, 'exit', props) 3587 }); 3588 }); 3589} 3590function getNextChildMapping(nextProps, prevChildMapping, onExited) { 3591 var nextChildMapping = getChildMapping(nextProps.children); 3592 var children = mergeChildMappings(prevChildMapping, nextChildMapping); 3593 Object.keys(children).forEach(function (key) { 3594 var child = children[key]; 3595 if (!(0,react.isValidElement)(child)) return; 3596 var hasPrev = (key in prevChildMapping); 3597 var hasNext = (key in nextChildMapping); 3598 var prevChild = prevChildMapping[key]; 3599 var isLeaving = (0,react.isValidElement)(prevChild) && !prevChild.props.in; // item is new (entering) 3600 3601 if (hasNext && (!hasPrev || isLeaving)) { 3602 // console.log('entering', key) 3603 children[key] = (0,react.cloneElement)(child, { 3604 onExited: onExited.bind(null, child), 3605 in: true, 3606 exit: getProp(child, 'exit', nextProps), 3607 enter: getProp(child, 'enter', nextProps) 3608 }); 3609 } else if (!hasNext && hasPrev && !isLeaving) { 3610 // item is old (exiting) 3611 // console.log('leaving', key) 3612 children[key] = (0,react.cloneElement)(child, { 3613 in: false 3614 }); 3615 } else if (hasNext && hasPrev && (0,react.isValidElement)(prevChild)) { 3616 // item hasn't changed transition states 3617 // copy over the last transition props; 3618 // console.log('unchanged', key) 3619 children[key] = (0,react.cloneElement)(child, { 3620 onExited: onExited.bind(null, child), 3621 in: prevChild.props.in, 3622 exit: getProp(child, 'exit', nextProps), 3623 enter: getProp(child, 'enter', nextProps) 3624 }); 3625 } 3626 }); 3627 return children; 3628} 3629;// ./node_modules/react-transition-group/esm/TransitionGroup.js 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639var values = Object.values || function (obj) { 3640 return Object.keys(obj).map(function (k) { 3641 return obj[k]; 3642 }); 3643}; 3644 3645var defaultProps = { 3646 component: 'div', 3647 childFactory: function childFactory(child) { 3648 return child; 3649 } 3650}; 3651/** 3652 * The `<TransitionGroup>` component manages a set of transition components 3653 * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition 3654 * components, `<TransitionGroup>` is a state machine for managing the mounting 3655 * and unmounting of components over time. 3656 * 3657 * Consider the example below. As items are removed or added to the TodoList the 3658 * `in` prop is toggled automatically by the `<TransitionGroup>`. 3659 * 3660 * Note that `<TransitionGroup>` does not define any animation behavior! 3661 * Exactly _how_ a list item animates is up to the individual transition 3662 * component. This means you can mix and match animations across different list 3663 * items. 3664 */ 3665 3666var TransitionGroup = /*#__PURE__*/function (_React$Component) { 3667 (0,inheritsLoose/* default */.A)(TransitionGroup, _React$Component); 3668 3669 function TransitionGroup(props, context) { 3670 var _this; 3671 3672 _this = _React$Component.call(this, props, context) || this; 3673 3674 var handleExited = _this.handleExited.bind((0,assertThisInitialized/* default */.A)(_this)); // Initial children should all be entering, dependent on appear 3675 3676 3677 _this.state = { 3678 contextValue: { 3679 isMounting: true 3680 }, 3681 handleExited: handleExited,
3682 firstRender: true 3683 }; 3684 return _this; 3685 } 3686 3687 var _proto = TransitionGroup.prototype; 3688 3689 _proto.componentDidMount = function componentDidMount() { 3690 this.mounted = true; 3691 this.setState({ 3692 contextValue: { 3693 isMounting: false 3694 } 3695 }); 3696 }; 3697 3698 _proto.componentWillUnmount = function componentWillUnmount() { 3699 this.mounted = false; 3700 }; 3701 3702 TransitionGroup.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) { 3703 var prevChildMapping = _ref.children, 3704 handleExited = _ref.handleExited, 3705 firstRender = _ref.firstRender; 3706 return { 3707 children: firstRender ? getInitialChildMapping(nextProps, handleExited) : getNextChildMapping(nextProps, prevChildMapping, handleExited), 3708 firstRender: false 3709 }; 3710 } // node is `undefined` when user provided `nodeRef` prop 3711 ; 3712 3713 _proto.handleExited = function handleExited(child, node) { 3714 var currentChildMapping = getChildMapping(this.props.children); 3715 if (child.key in currentChildMapping) return; 3716 3717 if (child.props.onExited) { 3718 child.props.onExited(node); 3719 } 3720 3721 if (this.mounted) { 3722 this.setState(function (state) { 3723 var children = (0,esm_extends/* default */.A)({}, state.children); 3724 3725 delete children[child.key]; 3726 return { 3727 children: children 3728 }; 3729 }); 3730 } 3731 }; 3732 3733 _proto.render = function render() { 3734 var _this$props = this.props, 3735 Component = _this$props.component, 3736 childFactory = _this$props.childFactory, 3737 props = (0,objectWithoutPropertiesLoose/* default */.A)(_this$props, ["component", "childFactory"]); 3738 3739 var contextValue = this.state.contextValue; 3740 var children = values(this.state.children).map(childFactory); 3741 delete props.appear; 3742 delete props.enter; 3743 delete props.exit; 3744 3745 if (Component === null) { 3746 return /*#__PURE__*/react.createElement(TransitionGroupContext/* default */.A.Provider, { 3747 value: contextValue 3748 }, children); 3749 } 3750 3751 return /*#__PURE__*/react.createElement(TransitionGroupContext/* default */.A.Provider, { 3752 value: contextValue 3753 }, /*#__PURE__*/react.createElement(Component, props, children)); 3754 }; 3755 3756 return TransitionGroup; 3757}(react.Component); 3758 3759TransitionGroup.propTypes = false ? 0 : {}; 3760TransitionGroup.defaultProps = defaultProps; 3761/* harmony default export */ const esm_TransitionGroup = (TransitionGroup); 3762 3763/***/ }), 3764 3765/***/ 7241: 3766/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 3767 3768"use strict"; 3769/* harmony export */ __webpack_require__.d(__webpack_exports__, { 3770/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__) 3771/* harmony export */ }); 3772/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6540); 3773 3774/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (react__WEBPACK_IMPORTED_MODULE_0__.createContext(null)); 3775 3776/***/ }), 3777 3778/***/ 5287: 3779/***/ ((__unused_webpack_module, exports) => { 3780 3781"use strict"; 3782/** 3783 * @license React 3784 * react.production.min.js 3785 * 3786 * Copyright (c) Facebook, Inc. and its affiliates. 3787 * 3788 * This source code is licensed under the MIT license found in the 3789 * LICENSE file in the root directory of this source tree. 3790 */ 3791var l=Symbol.for("react.element"),n=Symbol.for("react.portal"),p=Symbol.for("react.fragment"),q=Symbol.for("react.strict_mode"),r=Symbol.for("react.profiler"),t=Symbol.for("react.provider"),u=Symbol.for("react.context"),v=Symbol.for("react.forward_ref"),w=Symbol.for("react.suspense"),x=Symbol.for("react.memo"),y=Symbol.for("react.lazy"),z=Symbol.iterator;function A(a){if(null===a||"object"!==typeof a)return null;a=z&&a[z]||a["@@iterator"];return"function"===typeof a?a:null} 3792var B={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C=Object.assign,D={};function E(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}E.prototype.isReactComponent={}; 3793E.prototype.setState=function(a,b){if("object"!==typeof a&&"function"!==typeof a&&null!=a)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,a,b,"setState")};E.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,"forceUpdate")};function F(){}F.prototype=E.prototype;function G(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}var H=G.prototype=new F; 3794H.constructor=G;C(H,E.prototype);H.isPureReactComponent=!0;var I=Array.isArray,J=Object.prototype.hasOwnProperty,K={current:null},L={key:!0,ref:!0,__self:!0,__source:!0}; 3795function M(a,b,e){var d,c={},k=null,h=null;if(null!=b)for(d in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=""+b.key),b)J.call(b,d)&&!L.hasOwnProperty(d)&&(c[d]=b[d]);var g=arguments.length-2;if(1===g)c.children=e;else if(1<g){for(var f=Array(g),m=0;m<g;m++)f[m]=arguments[m+2];c.children=f}if(a&&a.defaultProps)for(d in g=a.defaultProps,g)void 0===c[d]&&(c[d]=g[d]);return{$$typeof:l,type:a,key:k,ref:h,props:c,_owner:K.current}} 3796function N(a,b){return{$$typeof:l,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}
vendor: 4,933 bytes, lines 3796-3825
3796function O(a){return"object"===typeof a&&null!==a&&a.$$typeof===l}function escape(a){var b={"=":"=0",":":"=2"};return"$"+a.replace(/[=:]/g,function(a){return b[a]})}var P=/\/+/g;function Q(a,b){return"object"===typeof a&&null!==a&&null!=a.key?escape(""+a.key):b.toString(36)} 3797function R(a,b,e,d,c){var k=typeof a;if("undefined"===k||"boolean"===k)a=null;var h=!1;if(null===a)h=!0;else switch(k){case "string":case "number":h=!0;break;case "object":switch(a.$$typeof){case l:case n:h=!0}}if(h)return h=a,c=c(h),a=""===d?"."+Q(h,0):d,I(c)?(e="",null!=a&&(e=a.replace(P,"$&/")+"/"),R(c,b,e,"",function(a){return a})):null!=c&&(O(c)&&(c=N(c,e+(!c.key||h&&h.key===c.key?"":(""+c.key).replace(P,"$&/")+"/")+a)),b.push(c)),1;h=0;d=""===d?".":d+":";if(I(a))for(var g=0;g<a.length;g++){k= 3798a[g];var f=d+Q(k,g);h+=R(k,b,e,f,c)}else if(f=A(a),"function"===typeof f)for(a=f.call(a),g=0;!(k=a.next()).done;)k=k.value,f=d+Q(k,g++),h+=R(k,b,e,f,c);else if("object"===k)throw b=String(a),Error("Objects are not valid as a React child (found: "+("[object Object]"===b?"object with keys {"+Object.keys(a).join(", ")+"}":b)+"). If you meant to render a collection of children, use an array instead.");return h} 3799function S(a,b,e){if(null==a)return a;var d=[],c=0;R(a,d,"","",function(a){return b.call(e,a,c++)});return d}function T(a){if(-1===a._status){var b=a._result;b=b();b.then(function(b){if(0===a._status||-1===a._status)a._status=1,a._result=b},function(b){if(0===a._status||-1===a._status)a._status=2,a._result=b});-1===a._status&&(a._status=0,a._result=b)}if(1===a._status)return a._result.default;throw a._result;} 3800var U={current:null},V={transition:null},W={ReactCurrentDispatcher:U,ReactCurrentBatchConfig:V,ReactCurrentOwner:K};function X(){throw Error("act(...) is not supported in production builds of React.");} 3801exports.Children={map:S,forEach:function(a,b,e){S(a,function(){b.apply(this,arguments)},e)},count:function(a){var b=0;S(a,function(){b++});return b},toArray:function(a){return S(a,function(a){return a})||[]},only:function(a){if(!O(a))throw Error("React.Children.only expected to receive a single React element child.");return a}};exports.Component=E;exports.Fragment=p;exports.Profiler=r;exports.PureComponent=G;exports.StrictMode=q;exports.Suspense=w; 3802exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=W;exports.act=X; 3803exports.cloneElement=function(a,b,e){if(null===a||void 0===a)throw Error("React.cloneElement(...): The argument must be a React element, but you passed "+a+".");var d=C({},a.props),c=a.key,k=a.ref,h=a._owner;if(null!=b){void 0!==b.ref&&(k=b.ref,h=K.current);void 0!==b.key&&(c=""+b.key);if(a.type&&a.type.defaultProps)var g=a.type.defaultProps;for(f in b)J.call(b,f)&&!L.hasOwnProperty(f)&&(d[f]=void 0===b[f]&&void 0!==g?g[f]:b[f])}var f=arguments.length-2;if(1===f)d.children=e;else if(1<f){g=Array(f); 3804for(var m=0;m<f;m++)g[m]=arguments[m+2];d.children=g}return{$$typeof:l,type:a.type,key:c,ref:k,props:d,_owner:h}};exports.createContext=function(a){a={$$typeof:u,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null};a.Provider={$$typeof:t,_context:a};return a.Consumer=a};exports.createElement=M;exports.createFactory=function(a){var b=M.bind(null,a);b.type=a;return b};exports.createRef=function(){return{current:null}}; 3805exports.forwardRef=function(a){return{$$typeof:v,render:a}};exports.isValidElement=O;exports.lazy=function(a){return{$$typeof:y,_payload:{_status:-1,_result:a},_init:T}};exports.memo=function(a,b){return{$$typeof:x,type:a,compare:void 0===b?null:b}};exports.startTransition=function(a){var b=V.transition;V.transition={};try{a()}finally{V.transition=b}};exports.unstable_act=X;exports.useCallback=function(a,b){return U.current.useCallback(a,b)};exports.useContext=function(a){return U.current.useContext(a)}; 3806exports.useDebugValue=function(){};exports.useDeferredValue=function(a){return U.current.useDeferredValue(a)};exports.useEffect=function(a,b){return U.current.useEffect(a,b)};exports.useId=function(){return U.current.useId()};exports.useImperativeHandle=function(a,b,e){return U.current.useImperativeHandle(a,b,e)};exports.useInsertionEffect=function(a,b){return U.current.useInsertionEffect(a,b)};exports.useLayoutEffect=function(a,b){return U.current.useLayoutEffect(a,b)}; 3807exports.useMemo=function(a,b){return U.current.useMemo(a,b)};exports.useReducer=function(a,b,e){return U.current.useReducer(a,b,e)};exports.useRef=function(a){return U.current.useRef(a)};exports.useState=function(a){return U.current.useState(a)};exports.useSyncExternalStore=function(a,b,e){return U.current.useSyncExternalStore(a,b,e)};exports.useTransition=function(){return U.current.useTransition()};exports.version="18.3.1"; 3808 3809 3810/***/ }), 3811 3812/***/ 6540: 3813/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 3814 3815"use strict"; 3816 3817 3818if (true) { 3819 module.exports = __webpack_require__(5287); 3820} else {} 3821 3822 3823/***/ }) 3824 3825}]);
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.