1/******/ (() => { // webpackBootstrap 2/******/ "use strict"; 3/******/ var __webpack_modules__ = ({ 4 5/***/ 644 6/*!*****************************************************************************!*\ 7 !*** ./node_modules/react-refresh/cjs/react-refresh-runtime.development.js ***! 8 \*****************************************************************************/ 9(__unused_webpack_module, exports) { 10 11/** 12 * @license React 13 * react-refresh-runtime.development.js 14 * 15 * Copyright (c) Facebook, Inc. and its affiliates. 16 * 17 * This source code is licensed under the MIT license found in the 18 * LICENSE file in the root directory of this source tree. 19 */ 20 21 22 23if (true) { 24 (function() { 25'use strict'; 26 27// ATTENTION 28var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref'); 29var REACT_MEMO_TYPE = Symbol.for('react.memo'); 30 31var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; // We never remove these associations. 32// It's OK to reference families, but use WeakMap/Set for types. 33 34var allFamiliesByID = new Map(); 35var allFamiliesByType = new PossiblyWeakMap(); 36var allSignaturesByType = new PossiblyWeakMap(); // This WeakMap is read by React, so we only put families 37// that have actually been edited here. This keeps checks fast. 38// $FlowIssue 39 40var updatedFamiliesByType = new PossiblyWeakMap(); // This is cleared on every performReactRefresh() call. 41// It is an array of [Family, NextType] tuples. 42 43var pendingUpdates = []; // This is injected by the renderer via DevTools global hook. 44 45var helpersByRendererID = new Map(); 46var helpersByRoot = new Map(); // We keep track of mounted roots so we can schedule updates. 47 48var mountedRoots = new Set(); // If a root captures an error, we remember it so we can retry on edit. 49 50var failedRoots = new Set(); // In environments that support WeakMap, we also remember the last element for every root. 51// It needs to be weak because we do this even for roots that failed to mount. 52// If there is no WeakMap, we won't attempt to do retrying. 53// $FlowIssue 54 55var rootElements = // $FlowIssue 56typeof WeakMap === 'function' ? new WeakMap() : null; 57var isPerformingRefresh = false; 58 59function computeFullKey(signature) { 60 if (signature.fullKey !== null) { 61 return signature.fullKey; 62 } 63 64 var fullKey = signature.ownKey; 65 var hooks; 66 67 try { 68 hooks = signature.getCustomHooks(); 69 } catch (err) {
70 // This can happen in an edge case, e.g. if expression like Foo.useSomething 71 // depends on Foo which is lazily initialized during rendering. 72 // In that case just assume we'll have to remount. 73 signature.forceReset = true; 74 signature.fullKey = fullKey; 75 return fullKey; 76 } 77 78 for (var i = 0; i < hooks.length; i++) { 79 var hook = hooks[i]; 80 81 if (typeof hook !== 'function') { 82 // Something's wrong. Assume we need to remount. 83 signature.forceReset = true; 84 signature.fullKey = fullKey; 85 return fullKey; 86 } 87 88 var nestedHookSignature = allSignaturesByType.get(hook); 89 90 if (nestedHookSignature === undefined) { 91 // No signature means Hook wasn't in the source code, e.g. in a library. 92 // We'll skip it because we can assume it won't change during this session. 93 continue; 94 } 95 96 var nestedHookKey = computeFullKey(nestedHookSignature); 97 98 if (nestedHookSignature.forceReset) { 99 signature.forceReset = true; 100 } 101 102 fullKey += '\n---\n' + nestedHookKey; 103 } 104 105 signature.fullKey = fullKey; 106 return fullKey; 107} 108 109function haveEqualSignatures(prevType, nextType) { 110 var prevSignature = allSignaturesByType.get(prevType); 111 var nextSignature = allSignaturesByType.get(nextType); 112 113 if (prevSignature === undefined && nextSignature === undefined) { 114 return true; 115 } 116 117 if (prevSignature === undefined || nextSignature === undefined) { 118 return false; 119 } 120 121 if (computeFullKey(prevSignature) !== computeFullKey(nextSignature)) { 122 return false; 123 } 124 125 if (nextSignature.forceReset) { 126 return false; 127 } 128 129 return true; 130} 131 132function isReactClass(type) { 133 return type.prototype && type.prototype.isReactComponent; 134} 135 136function canPreserveStateBetween(prevType, nextType) { 137 if (isReactClass(prevType) || isReactClass(nextType)) { 138 return false; 139 } 140 141 if (haveEqualSignatures(prevType, nextType)) { 142 return true; 143 } 144 145 return false; 146} 147 148function resolveFamily(type) { 149 // Only check updated types to keep lookups fast. 150 return updatedFamiliesByType.get(type); 151} // If we didn't care about IE11, we could use new Map/Set(iterable). 152 153 154function cloneMap(map) { 155 var clone = new Map(); 156 map.forEach(function (value, key) { 157 clone.set(key, value); 158 }); 159 return clone; 160} 161 162function cloneSet(set) { 163 var clone = new Set(); 164 set.forEach(function (value) { 165 clone.add(value); 166 }); 167 return clone; 168} // This is a safety mechanism to protect against rogue getters and Proxies. 169 170 171function getProperty(object, property) { 172 try { 173 return object[property]; 174 } catch (err) { 175 // Intentionally ignore. 176 return undefined; 177 } 178} 179 180function performReactRefresh() { 181 182 if (pendingUpdates.length === 0) { 183 return null; 184 } 185 186 if (isPerformingRefresh) { 187 return null; 188 } 189 190 isPerformingRefresh = true; 191 192 try { 193 var staleFamilies = new Set(); 194 var updatedFamilies = new Set(); 195 var updates = pendingUpdates; 196 pendingUpdates = []; 197 updates.forEach(function (_ref) { 198 var family = _ref[0], 199 nextType = _ref[1]; 200 // Now that we got a real edit, we can create associations 201 // that will be read by the React reconciler. 202 var prevType = family.current; 203 updatedFamiliesByType.set(prevType, family); 204 updatedFamiliesByType.set(nextType, family); 205 family.current = nextType; // Determine whether this should be a re-render or a re-mount. 206 207 if (canPreserveStateBetween(prevType, nextType)) { 208 updatedFamilies.add(family); 209 } else { 210 staleFamilies.add(family); 211 } 212 }); // TODO: rename these fields to something more meaningful. 213 214 var update = { 215 updatedFamilies: updatedFamilies, 216 // Families that will re-render preserving state 217 staleFamilies: staleFamilies // Families that will be remounted 218 219 }; 220 helpersByRendererID.forEach(function (helpers) { 221 // Even if there are no roots, set the handler on first update. 222 // This ensures that if *new* roots are mounted, they'll use the resolve handler. 223 helpers.setRefreshHandler(resolveFamily); 224 }); 225 var didError = false; 226 var firstError = null; // We snapshot maps and sets that are mutated during commits. 227 // If we don't do this, there is a risk they will be mutated while
228 // we iterate over them. For example, trying to recover a failed root 229 // may cause another root to be added to the failed list -- an infinite loop. 230 231 var failedRootsSnapshot = cloneSet(failedRoots); 232 var mountedRootsSnapshot = cloneSet(mountedRoots); 233 var helpersByRootSnapshot = cloneMap(helpersByRoot); 234 failedRootsSnapshot.forEach(function (root) { 235 var helpers = helpersByRootSnapshot.get(root); 236 237 if (helpers === undefined) { 238 throw new Error('Could not find helpers for a root. This is a bug in React Refresh.'); 239 } 240 241 if (!failedRoots.has(root)) {// No longer failed. 242 } 243 244 if (rootElements === null) { 245 return; 246 } 247 248 if (!rootElements.has(root)) { 249 return; 250 } 251 252 var element = rootElements.get(root); 253 254 try { 255 helpers.scheduleRoot(root, element); 256 } catch (err) { 257 if (!didError) { 258 didError = true; 259 firstError = err; 260 } // Keep trying other roots. 261 262 } 263 }); 264 mountedRootsSnapshot.forEach(function (root) { 265 var helpers = helpersByRootSnapshot.get(root); 266 267 if (helpers === undefined) { 268 throw new Error('Could not find helpers for a root. This is a bug in React Refresh.'); 269 } 270 271 if (!mountedRoots.has(root)) {// No longer mounted. 272 } 273 274 try { 275 helpers.scheduleRefresh(root, update); 276 } catch (err) { 277 if (!didError) { 278 didError = true; 279 firstError = err; 280 } // Keep trying other roots. 281 282 } 283 }); 284 285 if (didError) { 286 throw firstError; 287 } 288 289 return update; 290 } finally { 291 isPerformingRefresh = false; 292 } 293} 294function register(type, id) { 295 { 296 if (type === null) { 297 return; 298 } 299 300 if (typeof type !== 'function' && typeof type !== 'object') { 301 return; 302 }
302 // This can happen in an edge case, e.g. if we register 303 // return value of a HOC but it returns a cached component. 304 // Ignore anything but the first registration for each type. 305 306 307 if (allFamiliesByType.has(type)) { 308 return; 309 } // Create family or remember to update it. 310 // None of this bookkeeping affects reconciliation 311 // until the first performReactRefresh() call above. 312 313 314 var family = allFamiliesByID.get(id); 315 316 if (family === undefined) { 317 family = { 318 current: type 319 }; 320 allFamiliesByID.set(id, family); 321 } else { 322 pendingUpdates.push([family, type]); 323 } 324 325 allFamiliesByType.set(type, family); // Visit inner types because we might not have registered them. 326 327 if (typeof type === 'object' && type !== null) { 328 switch (getProperty(type, '$$typeof')) { 329 case REACT_FORWARD_REF_TYPE: 330 register(type.render, id + '$render'); 331 break; 332 333 case REACT_MEMO_TYPE: 334 register(type.type, id + '$type'); 335 break; 336 } 337 } 338 } 339} 340function setSignature(type, key) { 341 var forceReset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; 342 var getCustomHooks = arguments.length > 3 ? arguments[3] : undefined; 343 344 { 345 if (!allSignaturesByType.has(type)) { 346 allSignaturesByType.set(type, { 347 forceReset: forceReset, 348 ownKey: key, 349 fullKey: null, 350 getCustomHooks: getCustomHooks || function () { 351 return []; 352 } 353 }); 354 } // Visit inner types because we might not have signed them. 355 356 357 if (typeof type === 'object' && type !== null) { 358 switch (getProperty(type, '$$typeof')) { 359 case REACT_FORWARD_REF_TYPE: 360 setSignature(type.render, key, forceReset, getCustomHooks); 361 break; 362 363 case REACT_MEMO_TYPE: 364 setSignature(type.type, key, forceReset, getCustomHooks); 365 break; 366 } 367 } 368 } 369} // This is lazily called during first render for a type. 370// It captures Hook list at that time so inline requires don't break comparisons. 371 372function collectCustomHooksForSignature(type) { 373 { 374 var signature = allSignaturesByType.get(type); 375 376 if (signature !== undefined) { 377 computeFullKey(signature); 378 } 379 } 380} 381function getFamilyByID(id) { 382 { 383 return allFamiliesByID.get(id); 384 } 385} 386function getFamilyByType(type) { 387 { 388 return allFamiliesByType.get(type); 389 } 390} 391function findAffectedHostInstances(families) { 392 { 393 var affectedInstances = new Set(); 394 mountedRoots.forEach(function (root) { 395 var helpers = helpersByRoot.get(root); 396 397 if (helpers === undefined) { 398 throw new Error('Could not find helpers for a root. This is a bug in React Refresh.'); 399 } 400 401 var instancesForRoot = helpers.findHostInstancesForRefresh(root, families); 402 instancesForRoot.forEach(function (inst) { 403 affectedInstances.add(inst); 404 }); 405 }); 406 return affectedInstances; 407 } 408} 409function injectIntoGlobalHook(globalObject) { 410 { 411 // For React Native, the global hook will be set up by require('react-devtools-core'). 412 // That code will run before us. So we need to monkeypatch functions on existing hook. 413 // For React Web, the global hook will be set up by the extension. 414 // This will also run before us. 415 var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__; 416 417 if (hook === undefined) { 418 // However, if there is no DevTools extension, we'll need to set up the global hook ourselves. 419 // Note that in this case it's important that renderer code runs *after* this method call. 420 // Otherwise, the renderer will think that there is no global hook, and won't do the injection. 421 var nextID = 0; 422 globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = { 423 renderers: new Map(), 424 supportsFiber: true, 425 inject: function (injected) { 426 return nextID++; 427 }, 428 onScheduleFiberRoot: function (id, root, children) {}, 429 onCommitFiberRoot: function (id, root, maybePriorityLevel, didError) {}, 430 onCommitFiberUnmount: function () {} 431 }; 432 } 433 434 if (hook.isDisabled) { 435 // This isn't a real property on the hook, but it can be set to opt out 436 // of DevTools integration and associated warnings and logs. 437 // Using console['warn'] to evade Babel and ESLint 438 console['warn']('Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). ' + 'Fast Refresh is not compatible with this shim and will be disabled.'); 439 return; 440 } // Here, we just want to get a reference to scheduleRefresh. 441 442 443 var oldInject = hook.inject; 444 445 hook.inject = function (injected) { 446 var id = oldInject.apply(this, arguments); 447 448 if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') { 449 // This version supports React Refresh. 450 helpersByRendererID.set(id, injected); 451 } 452 453 return id; 454 }; // Do the same for any already injected roots. 455 // This is useful if ReactDOM has already been initialized. 456 // https://github.com/facebook/react/issues/17626 457 458
459 hook.renderers.forEach(function (injected, id) { 460 if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') { 461 // This version supports React Refresh. 462 helpersByRendererID.set(id, injected); 463 } 464 }); // We also want to track currently mounted roots. 465 466 var oldOnCommitFiberRoot = hook.onCommitFiberRoot; 467 468 var oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function () {}; 469 470 hook.onScheduleFiberRoot = function (id, root, children) { 471 if (!isPerformingRefresh) { 472 // If it was intentionally scheduled, don't attempt to restore. 473 // This includes intentionally scheduled unmounts. 474 failedRoots.delete(root); 475 476 if (rootElements !== null) { 477 rootElements.set(root, children); 478 } 479 } 480 481 return oldOnScheduleFiberRoot.apply(this, arguments); 482 }; 483 484 hook.onCommitFiberRoot = function (id, root, maybePriorityLevel, didError) { 485 var helpers = helpersByRendererID.get(id); 486 487 if (helpers !== undefined) { 488 helpersByRoot.set(root, helpers); 489 var current = root.current; 490 var alternate = current.alternate; // We need to determine whether this root has just (un)mounted. 491 // This logic is copy-pasted from similar logic in the DevTools backend. 492 // If this breaks with some refactoring, you'll want to update DevTools too. 493 494 if (alternate !== null) { 495 var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null && mountedRoots.has(root); 496 var isMounted = current.memoizedState != null && current.memoizedState.element != null; 497 498 if (!wasMounted && isMounted) { 499 // Mount a new root. 500 mountedRoots.add(root); 501 failedRoots.delete(root); 502 } else if (wasMounted && isMounted) ; else if (wasMounted && !isMounted) { 503 // Unmount an existing root. 504 mountedRoots.delete(root); 505 506 if (didError) { 507 // We'll remount it on future edits. 508 failedRoots.add(root); 509 } else { 510 helpersByRoot.delete(root); 511 } 512 } else if (!wasMounted && !isMounted) { 513 if (didError) { 514 // We'll remount it on future edits. 515 failedRoots.add(root); 516 } 517 } 518 } else { 519 // Mount a new root. 520 mountedRoots.add(root); 521 } 522 } // Always call the decorated DevTools hook. 523 524 525 return oldOnCommitFiberRoot.apply(this, arguments); 526 }; 527 } 528} 529function hasUnrecoverableErrors() { 530 // TODO: delete this after removing dependency in RN. 531 return false; 532} // Exposed for testing. 533 534function _getMountedRootCount() { 535 { 536 return mountedRoots.size; 537 } 538} // This is a wrapper over more primitive functions for setting signature. 539// Signatures let us decide whether the Hook order has changed on refresh. 540// 541// This function is intended to be used as a transform target, e.g.: 542// var _s = createSignatureFunctionForTransform() 543// 544// function Hello() { 545// const [foo, setFoo] = useState(0); 546// const value = useCustomHook(); 547// _s(); /* Call without arguments triggers collecting the custom Hook list. 548// * This doesn't happen during the module evaluation because we 549// * don't want to change the module order with inline requires. 550// * Next calls are noops. */ 551// return <h1>Hi</h1>; 552// } 553// 554// /* Call with arguments attaches the signature to the type: */ 555// _s( 556// Hello, 557// 'useState{[foo, setFoo]}(0)', 558// () => [useCustomHook], /* Lazy to avoid triggering inline requires */ 559// ); 560 561function createSignatureFunctionForTransform() { 562 { 563 var savedType; 564 var hasCustomHooks; 565 var didCollectHooks = false; 566 return function (type, key, forceReset, getCustomHooks) { 567 if (typeof key === 'string') { 568 // We're in the initial phase that associates signatures 569 // with the functions. Note this may be called multiple times 570 // in HOC chains like _s(hoc1(_s(hoc2(_s(actualFunction))))). 571 if (!savedType) { 572 // We're in the innermost call, so this is the actual type. 573 savedType = type; 574 hasCustomHooks = typeof getCustomHooks === 'function'; 575 } // Set the signature for all types (even wrappers!) in case 576 // they have no signatures of their own. This is to prevent 577 // problems like https://github.com/facebook/react/issues/20417. 578 579 580 if (type != null && (typeof type === 'function' || typeof type === 'object')) { 581 setSignature(type, key, forceReset, getCustomHooks); 582 } 583 584 return type; 585 } else { 586 // We're in the _s() call without arguments, which means 587 // this is the time to collect custom Hook signatures. 588 // Only do this once. This path is hot and runs *inside* every render! 589 if (!didCollectHooks && hasCustomHooks) { 590 didCollectHooks = true; 591 collectCustomHooksForSignature(savedType); 592 } 593 } 594 }; 595 } 596} 597function isLikelyComponentType(type) { 598 { 599 switch (typeof type) { 600 case 'function': 601 { 602 // First, deal with classes. 603 if (type.prototype != null) { 604 if (type.prototype.isReactComponent) { 605 // React class. 606 return true; 607 } 608 609 var ownNames = Object.getOwnPropertyNames(type.prototype); 610 611 if (ownNames.length > 1 || ownNames[0] !== 'constructor') { 612 // This looks like a class. 613 return false;
614 } // eslint-disable-next-line no-proto 615 616 617 if (type.prototype.__proto__ !== Object.prototype) { 618 // It has a superclass. 619 return false; 620 } // Pass through. 621 // This looks like a regular function with empty prototype. 622 623 } // For plain functions and arrows, use name as a heuristic. 624 625 626 var name = type.name || type.displayName; 627 return typeof name === 'string' && /^[A-Z]/.test(name); 628 } 629 630 case 'object': 631 { 632 if (type != null) { 633 switch (getProperty(type, '$$typeof')) { 634 case REACT_FORWARD_REF_TYPE: 635 case REACT_MEMO_TYPE: 636 // Definitely React components. 637 return true; 638 639 default: 640 return false; 641 } 642 } 643 644 return false; 645 } 646 647 default: 648 { 649 return false; 650 } 651 } 652 } 653} 654 655exports._getMountedRootCount = _getMountedRootCount; 656exports.collectCustomHooksForSignature = collectCustomHooksForSignature; 657exports.createSignatureFunctionForTransform = createSignatureFunctionForTransform; 658exports.findAffectedHostInstances = findAffectedHostInstances; 659exports.getFamilyByID = getFamilyByID; 660exports.getFamilyByType = getFamilyByType; 661exports.hasUnrecoverableErrors = hasUnrecoverableErrors; 662exports.injectIntoGlobalHook = injectIntoGlobalHook; 663exports.isLikelyComponentType = isLikelyComponentType; 664exports.performReactRefresh = performReactRefresh; 665exports.register = register; 666exports.setSignature = setSignature; 667 })(); 668} 669 670 671/***/ }, 672 673/***/ 206 674/*!***********************************************!*\ 675 !*** ./node_modules/react-refresh/runtime.js ***! 676 \***********************************************/ 677(module, __unused_webpack_exports, __webpack_require__) { 678 679 680 681if (false) // removed by dead control flow 682{} else { 683 module.exports = __webpack_require__(/*! ./cjs/react-refresh-runtime.development.js */ 644); 684} 685 686 687/***/ } 688 689/******/ }); 690/************************************************************************/ 691/******/ // The module cache 692/******/ var __webpack_module_cache__ = {}; 693/******/ 694/******/ // The require function 695/******/ function __webpack_require__(moduleId) { 696/******/ // Check if module is in cache 697/******/ var cachedModule = __webpack_module_cache__[moduleId]; 698/******/ if (cachedModule !== undefined) { 699/******/ return cachedModule.exports; 700/******/ } 701/******/ // Create a new module (and put it into the cache) 702/******/ var module = __webpack_module_cache__[moduleId] = { 703/******/ // no module.id needed 704/******/ // no module.loaded needed 705/******/ exports: {} 706/******/ }; 707/******/ 708/******/ // Execute the module function 709/******/ if (!(moduleId in __webpack_modules__)) { 710/******/ delete __webpack_module_cache__[moduleId]; 711/******/ var e = new Error("Cannot find module '" + moduleId + "'"); 712/******/ e.code = 'MODULE_NOT_FOUND'; 713/******/ throw e; 714/******/ } 715/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); 716/******/ 717/******/ // Return the exports of the module 718/******/ return module.exports; 719/******/ } 720/******/ 721/************************************************************************/ 722/******/ 723/******/ // startup 724/******/ // Load entry module and return exports 725/******/ // This entry module used 'module' so it can't be inlined 726/******/ var __webpack_exports__ = __webpack_require__(206); 727/******/ window.ReactRefreshRuntime = __webpack_exports__; 728/******/ 729/******/ })() 730;
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.