1(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push([typeof document === "object" ? document.currentScript : undefined, 2"[project]/node_modules/next/dist/compiled/process/browser.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => { 3 4(function() { 5 var e = { 6 229: function(e) { 7 var t = e.exports = {}; 8 var r; 9 var n; 10 function defaultSetTimout() { 11 throw new Error("setTimeout has not been defined"); 12 } 13 function defaultClearTimeout() { 14 throw new Error("clearTimeout has not been defined"); 15 } 16 (function() { 17 try { 18 if (typeof setTimeout === "function") { 19 r = setTimeout; 20 } else { 21 r = defaultSetTimout; 22 } 23 } catch (e) { 24 r = defaultSetTimout; 25 } 26 try { 27 if (typeof clearTimeout === "function") { 28 n = clearTimeout; 29 } else { 30 n = defaultClearTimeout; 31 } 32 } catch (e) { 33 n = defaultClearTimeout; 34 } 35 })(); 36 function runTimeout(e) { 37 if (r === setTimeout) { 38 return setTimeout(e, 0); 39 } 40 if ((r === defaultSetTimout || !r) && setTimeout) { 41 r = setTimeout; 42 return setTimeout(e, 0); 43 } 44 try { 45 return r(e, 0); 46 } catch (t) { 47 try { 48 return r.call(null, e, 0); 49 } catch (t) { 50 return r.call(this, e, 0); 51 } 52 } 53 } 54 function runClearTimeout(e) { 55 if (n === clearTimeout) { 56 return clearTimeout(e); 57 } 58 if ((n === defaultClearTimeout || !n) && clearTimeout) { 59 n = clearTimeout; 60 return clearTimeout(e); 61 } 62 try { 63 return n(e); 64 } catch (t) { 65 try { 66 return n.call(null, e); 67 } catch (t) { 68 return n.call(this, e); 69 } 70 } 71 } 72 var i = []; 73 var o = false; 74 var u; 75 var a = -1; 76 function cleanUpNextTick() { 77 if (!o || !u) { 78 return; 79 } 80 o = false; 81 if (u.length) { 82 i = u.concat(i); 83 } else { 84 a = -1; 85 } 86 if (i.length) { 87 drainQueue(); 88 } 89 } 90 function drainQueue() { 91 if (o) { 92 return; 93 } 94 var e = runTimeout(cleanUpNextTick); 95 o = true; 96 var t = i.length; 97 while(t){ 98 u = i; 99 i = []; 100 while(++a < t){ 101 if (u) { 102 u[a].run(); 103 } 104 } 105 a = -1; 106 t = i.length; 107 } 108 u = null; 109 o = false; 110 runClearTimeout(e); 111 } 112 t.nextTick = function(e) { 113 var t = new Array(arguments.length - 1); 114 if (arguments.length > 1) { 115 for(var r = 1; r < arguments.length; r++){ 116 t[r - 1] = arguments[r]; 117 } 118 } 119 i.push(new Item(e, t)); 120 if (i.length === 1 && !o) { 121 runTimeout(drainQueue); 122 } 123 }; 124 function Item(e, t) { 125 this.fun = e; 126 this.array = t; 127 } 128 Item.prototype.run = function() { 129 this.fun.apply(null, this.array); 130 }; 131 t.title = "browser"; 132 t.browser = true; 133 t.env = {}; 134 t.argv = []; 135 t.version = ""; 136 t.versions = {}; 137 function noop() {} 138 t.on = noop; 139 t.addListener = noop; 140 t.once = noop; 141 t.off = noop; 142 t.removeListener = noop; 143 t.removeAllListeners = noop; 144 t.emit = noop; 145 t.prependListener = noop; 146 t.prependOnceListener = noop; 147 t.listeners = function(e) { 148 return []; 149 }; 150 t.binding = function(e) { 151 throw new Error("process.binding is not supported"); 152 }; 153 t.cwd = function() { 154 return "/"; 155 }; 156 t.chdir = function(e) { 157 throw new Error("process.chdir is not supported"); 158 }; 159 t.umask = function() { 160 return 0; 161 }; 162 } 163 }; 164 var t = {}; 165 function __nccwpck_require__(r) { 166 var n = t[r]; 167 if (n !== undefined) { 168 return n.exports; 169 } 170 var i = t[r] = { 171 exports: {} 172 }; 173 var o = true; 174 try { 175 e[r](i, i.exports, __nccwpck_require__); 176 o = false;
177 } finally{ 178 if (o) delete t[r]; 179 } 180 return i.exports; 181 } 182 if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = ("TURBOPACK compile-time value", "/ROOT/node_modules/next/dist/compiled/process") + "/"; 183 var r = __nccwpck_require__(229); 184 module.exports = r; 185})(); 186}), 187"[project]/node_modules/next/dist/compiled/react-refresh/cjs/react-refresh-runtime.development.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => { 188"use strict"; 189 190var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)"); 191/** 192 * @license React 193 * react-refresh-runtime.development.js 194 * 195 * Copyright (c) Facebook, Inc. and its affiliates. 196 * 197 * This source code is licensed under the MIT license found in the 198 * LICENSE file in the root directory of this source tree. 199 */ 'use strict'; 200if ("TURBOPACK compile-time truthy", 1) { 201 (function() { 202 'use strict'; 203 // ATTENTION 204 var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref'); 205 var REACT_MEMO_TYPE = Symbol.for('react.memo'); 206 var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; // We never remove these associations. 207 // It's OK to reference families, but use WeakMap/Set for types. 208 var allFamiliesByID = new Map(); 209 var allFamiliesByType = new PossiblyWeakMap(); 210 var allSignaturesByType = new PossiblyWeakMap(); // This WeakMap is read by React, so we only put families 211 // that have actually been edited here. This keeps checks fast. 212 // $FlowIssue 213 var updatedFamiliesByType = new PossiblyWeakMap(); // This is cleared on every performReactRefresh() call. 214 // It is an array of [Family, NextType] tuples. 215 var pendingUpdates = []; // This is injected by the renderer via DevTools global hook. 216 var helpersByRendererID = new Map(); 217 var helpersByRoot = new Map(); // We keep track of mounted roots so we can schedule updates. 218 var mountedRoots = new Set(); // If a root captures an error, we remember it so we can retry on edit. 219 var failedRoots = new Set(); // In environments that support WeakMap, we also remember the last element for every root. 220 // It needs to be weak because we do this even for roots that failed to mount. 221 // If there is no WeakMap, we won't attempt to do retrying. 222 // $FlowIssue 223 var rootElements = typeof WeakMap === 'function' ? new WeakMap() : null; 224 var isPerformingRefresh = false; 225 function computeFullKey(signature) { 226 if (signature.fullKey !== null) { 227 return signature.fullKey; 228 } 229 var fullKey = signature.ownKey; 230 var hooks; 231 try { 232 hooks = signature.getCustomHooks(); 233 } catch (err) {
234 // This can happen in an edge case, e.g. if expression like Foo.useSomething 235 // depends on Foo which is lazily initialized during rendering. 236 // In that case just assume we'll have to remount. 237 signature.forceReset = true; 238 signature.fullKey = fullKey; 239 return fullKey; 240 } 241 for(var i = 0; i < hooks.length; i++){ 242 var hook = hooks[i]; 243 if (typeof hook !== 'function') { 244 // Something's wrong. Assume we need to remount. 245 signature.forceReset = true; 246 signature.fullKey = fullKey; 247 return fullKey; 248 } 249 var nestedHookSignature = allSignaturesByType.get(hook); 250 if (nestedHookSignature === undefined) { 251 continue; 252 } 253 var nestedHookKey = computeFullKey(nestedHookSignature); 254 if (nestedHookSignature.forceReset) { 255 signature.forceReset = true; 256 } 257 fullKey += '\n---\n' + nestedHookKey; 258 } 259 signature.fullKey = fullKey; 260 return fullKey; 261 } 262 function haveEqualSignatures(prevType, nextType) { 263 var prevSignature = allSignaturesByType.get(prevType); 264 var nextSignature = allSignaturesByType.get(nextType); 265 if (prevSignature === undefined && nextSignature === undefined) { 266 return true; 267 } 268 if (prevSignature === undefined || nextSignature === undefined) { 269 return false; 270 } 271 if (computeFullKey(prevSignature) !== computeFullKey(nextSignature)) { 272 return false; 273 } 274 if (nextSignature.forceReset) { 275 return false; 276 } 277 return true; 278 } 279 function isReactClass(type) { 280 return type.prototype && type.prototype.isReactComponent; 281 } 282 function canPreserveStateBetween(prevType, nextType) { 283 if (isReactClass(prevType) || isReactClass(nextType)) { 284 return false; 285 } 286 if (haveEqualSignatures(prevType, nextType)) { 287 return true; 288 } 289 return false; 290 } 291 function resolveFamily(type) { 292 // Only check updated types to keep lookups fast. 293 return updatedFamiliesByType.get(type); 294 } // If we didn't care about IE11, we could use new Map/Set(iterable). 295 function cloneMap(map) { 296 var clone = new Map(); 297 map.forEach(function(value, key) { 298 clone.set(key, value); 299 }); 300 return clone; 301 } 302 function cloneSet(set) { 303 var clone = new Set(); 304 set.forEach(function(value) { 305 clone.add(value); 306 }); 307 return clone; 308 } // This is a safety mechanism to protect against rogue getters and Proxies. 309 function getProperty(object, property) { 310 try { 311 return object[property]; 312 } catch (err) { 313 // Intentionally ignore. 314 return undefined; 315 } 316 } 317 function performReactRefresh() { 318 if (pendingUpdates.length === 0) { 319 return null; 320 } 321 if (isPerformingRefresh) { 322 return null; 323 } 324 isPerformingRefresh = true; 325 try { 326 var staleFamilies = new Set(); 327 var updatedFamilies = new Set(); 328 var updates = pendingUpdates; 329 pendingUpdates = []; 330 updates.forEach(function(_ref) { 331 var family = _ref[0], nextType = _ref[1]; 332 // Now that we got a real edit, we can create associations 333 // that will be read by the React reconciler. 334 var prevType = family.current; 335 updatedFamiliesByType.set(prevType, family); 336 updatedFamiliesByType.set(nextType, family); 337 family.current = nextType; // Determine whether this should be a re-render or a re-mount. 338 if (canPreserveStateBetween(prevType, nextType)) { 339 updatedFamilies.add(family); 340 } else { 341 staleFamilies.add(family); 342 } 343 }); // TODO: rename these fields to something more meaningful. 344 var update = { 345 updatedFamilies: updatedFamilies, 346 // Families that will re-render preserving state 347 staleFamilies: staleFamilies // Families that will be remounted 348 };
349 helpersByRendererID.forEach(function(helpers) { 350 // Even if there are no roots, set the handler on first update. 351 // This ensures that if *new* roots are mounted, they'll use the resolve handler. 352 helpers.setRefreshHandler(resolveFamily); 353 }); 354 var didError = false; 355 var firstError = null; // We snapshot maps and sets that are mutated during commits. 356 // If we don't do this, there is a risk they will be mutated while 357 // we iterate over them. For example, trying to recover a failed root 358 // may cause another root to be added to the failed list -- an infinite loop. 359 var failedRootsSnapshot = cloneSet(failedRoots); 360 var mountedRootsSnapshot = cloneSet(mountedRoots); 361 var helpersByRootSnapshot = cloneMap(helpersByRoot); 362 failedRootsSnapshot.forEach(function(root) { 363 var helpers = helpersByRootSnapshot.get(root); 364 if (helpers === undefined) { 365 throw new Error('Could not find helpers for a root. This is a bug in React Refresh.'); 366 } 367 if (!failedRoots.has(root)) {} 368 if (rootElements === null) { 369 return; 370 } 371 if (!rootElements.has(root)) { 372 return; 373 } 374 var element = rootElements.get(root); 375 try { 376 helpers.scheduleRoot(root, element); 377 } catch (err) { 378 if (!didError) { 379 didError = true; 380 firstError = err; 381 } // Keep trying other roots. 382 } 383 }); 384 mountedRootsSnapshot.forEach(function(root) { 385 var helpers = helpersByRootSnapshot.get(root); 386 if (helpers === undefined) { 387 throw new Error('Could not find helpers for a root. This is a bug in React Refresh.'); 388 } 389 if (!mountedRoots.has(root)) {} 390 try { 391 helpers.scheduleRefresh(root, update); 392 } catch (err) { 393 if (!didError) { 394 didError = true; 395 firstError = err; 396 } // Keep trying other roots. 397 } 398 }); 399 if (didError) { 400 throw firstError; 401 } 402 return update; 403 } finally{ 404 isPerformingRefresh = false; 405 } 406 } 407 function register(type, id) { 408 { 409 if (type === null) { 410 return; 411 } 412 if (typeof type !== 'function' && typeof type !== 'object') { 413 return; 414 }
414 // This can happen in an edge case, e.g. if we register 415 // return value of a HOC but it returns a cached component. 416 // Ignore anything but the first registration for each type. 417 if (allFamiliesByType.has(type)) { 418 return; 419 } // Create family or remember to update it. 420 // None of this bookkeeping affects reconciliation 421 // until the first performReactRefresh() call above. 422 var family = allFamiliesByID.get(id); 423 if (family === undefined) { 424 family = { 425 current: type 426 }; 427 allFamiliesByID.set(id, family); 428 } else { 429 pendingUpdates.push([ 430 family, 431 type 432 ]); 433 } 434 allFamiliesByType.set(type, family); // Visit inner types because we might not have registered them. 435 if (typeof type === 'object' && type !== null) { 436 switch(getProperty(type, '$$typeof')){ 437 case REACT_FORWARD_REF_TYPE: 438 register(type.render, id + '$render'); 439 break; 440 case REACT_MEMO_TYPE: 441 register(type.type, id + '$type'); 442 break; 443 } 444 } 445 } 446 } 447 function setSignature(type, key) { 448 var forceReset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; 449 var getCustomHooks = arguments.length > 3 ? arguments[3] : undefined; 450 { 451 if (!allSignaturesByType.has(type)) { 452 allSignaturesByType.set(type, { 453 forceReset: forceReset, 454 ownKey: key, 455 fullKey: null, 456 getCustomHooks: getCustomHooks || function() { 457 return []; 458 } 459 }); 460 } // Visit inner types because we might not have signed them. 461 if (typeof type === 'object' && type !== null) { 462 switch(getProperty(type, '$$typeof')){ 463 case REACT_FORWARD_REF_TYPE: 464 setSignature(type.render, key, forceReset, getCustomHooks); 465 break; 466 case REACT_MEMO_TYPE: 467 setSignature(type.type, key, forceReset, getCustomHooks); 468 break; 469 } 470 } 471 } 472 } // This is lazily called during first render for a type. 473 // It captures Hook list at that time so inline requires don't break comparisons. 474 function collectCustomHooksForSignature(type) { 475 { 476 var signature = allSignaturesByType.get(type); 477 if (signature !== undefined) { 478 computeFullKey(signature); 479 } 480 } 481 } 482 function getFamilyByID(id) { 483 { 484 return allFamiliesByID.get(id); 485 } 486 } 487 function getFamilyByType(type) { 488 { 489 return allFamiliesByType.get(type); 490 } 491 } 492 function findAffectedHostInstances(families) { 493 { 494 var affectedInstances = new Set(); 495 mountedRoots.forEach(function(root) { 496 var helpers = helpersByRoot.get(root); 497 if (helpers === undefined) { 498 throw new Error('Could not find helpers for a root. This is a bug in React Refresh.'); 499 } 500 var instancesForRoot = helpers.findHostInstancesForRefresh(root, families); 501 instancesForRoot.forEach(function(inst) { 502 affectedInstances.add(inst); 503 }); 504 }); 505 return affectedInstances; 506 } 507 } 508 function injectIntoGlobalHook(globalObject) { 509 { 510 // For React Native, the global hook will be set up by require('react-devtools-core'). 511 // That code will run before us. So we need to monkeypatch functions on existing hook. 512 // For React Web, the global hook will be set up by the extension. 513 // This will also run before us. 514 var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__; 515 if (hook === undefined) { 516 // However, if there is no DevTools extension, we'll need to set up the global hook ourselves. 517 // Note that in this case it's important that renderer code runs *after* this method call. 518 // Otherwise, the renderer will think that there is no global hook, and won't do the injection. 519 var nextID = 0; 520 globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = { 521 renderers: new Map(), 522 supportsFiber: true, 523 inject: function(injected) { 524 return nextID++; 525 }, 526 onScheduleFiberRoot: function(id, root, children) {}, 527 onCommitFiberRoot: function(id, root, maybePriorityLevel, didError) {}, 528 onCommitFiberUnmount: function() {} 529 }; 530 } 531 if (hook.isDisabled) { 532 // This isn't a real property on the hook, but it can be set to opt out 533 // of DevTools integration and associated warnings and logs. 534 // Using console['warn'] to evade Babel and ESLint 535 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.'); 536 return; 537 } // Here, we just want to get a reference to scheduleRefresh. 538 var oldInject = hook.inject; 539 hook.inject = function(injected) { 540 var id = oldInject.apply(this, arguments); 541 if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') { 542 // This version supports React Refresh. 543 helpersByRendererID.set(id, injected); 544 } 545 return id; 546 }; // Do the same for any already injected roots. 547 // This is useful if ReactDOM has already been initialized. 548 // https://github.com/facebook/react/issues/17626
549 hook.renderers.forEach(function(injected, id) { 550 if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') { 551 // This version supports React Refresh. 552 helpersByRendererID.set(id, injected); 553 } 554 }); // We also want to track currently mounted roots. 555 var oldOnCommitFiberRoot = hook.onCommitFiberRoot; 556 var oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function() {}; 557 hook.onScheduleFiberRoot = function(id, root, children) { 558 if (!isPerformingRefresh) { 559 // If it was intentionally scheduled, don't attempt to restore. 560 // This includes intentionally scheduled unmounts. 561 failedRoots.delete(root); 562 if (rootElements !== null) { 563 rootElements.set(root, children); 564 } 565 } 566 return oldOnScheduleFiberRoot.apply(this, arguments); 567 }; 568 hook.onCommitFiberRoot = function(id, root, maybePriorityLevel, didError) { 569 var helpers = helpersByRendererID.get(id); 570 if (helpers !== undefined) { 571 helpersByRoot.set(root, helpers); 572 var current = root.current; 573 var alternate = current.alternate; // We need to determine whether this root has just (un)mounted. 574 // This logic is copy-pasted from similar logic in the DevTools backend. 575 // If this breaks with some refactoring, you'll want to update DevTools too. 576 if (alternate !== null) { 577 var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null && mountedRoots.has(root); 578 var isMounted = current.memoizedState != null && current.memoizedState.element != null; 579 if (!wasMounted && isMounted) { 580 // Mount a new root. 581 mountedRoots.add(root); 582 failedRoots.delete(root); 583 } else if (wasMounted && isMounted) ; 584 else if (wasMounted && !isMounted) { 585 // Unmount an existing root. 586 mountedRoots.delete(root); 587 if (didError) { 588 // We'll remount it on future edits. 589 failedRoots.add(root); 590 } else { 591 helpersByRoot.delete(root); 592 } 593 } else if (!wasMounted && !isMounted) { 594 if (didError) { 595 // We'll remount it on future edits. 596 failedRoots.add(root); 597 } 598 } 599 } else { 600 // Mount a new root. 601 mountedRoots.add(root); 602 } 603 } // Always call the decorated DevTools hook. 604 return oldOnCommitFiberRoot.apply(this, arguments); 605 }; 606 } 607 } 608 function hasUnrecoverableErrors() { 609 // TODO: delete this after removing dependency in RN. 610 return false; 611 } // Exposed for testing. 612 function _getMountedRootCount() { 613 { 614 return mountedRoots.size; 615 } 616 } // This is a wrapper over more primitive functions for setting signature. 617 // Signatures let us decide whether the Hook order has changed on refresh. 618 // 619 // This function is intended to be used as a transform target, e.g.: 620 // var _s = createSignatureFunctionForTransform() 621 // 622 // function Hello() { 623 // const [foo, setFoo] = useState(0); 624 // const value = useCustomHook(); 625 // _s(); /* Call without arguments triggers collecting the custom Hook list. 626 // * This doesn't happen during the module evaluation because we 627 // * don't want to change the module order with inline requires. 628 // * Next calls are noops. */ 629 // return <h1>Hi</h1>; 630 // } 631 // 632 // /* Call with arguments attaches the signature to the type: */ 633 // _s( 634 // Hello, 635 // 'useState{[foo, setFoo]}(0)', 636 // () => [useCustomHook], /* Lazy to avoid triggering inline requires */ 637 // ); 638 function createSignatureFunctionForTransform() { 639 { 640 var savedType; 641 var hasCustomHooks; 642 var didCollectHooks = false;
643 return function(type, key, forceReset, getCustomHooks) { 644 if (typeof key === 'string') { 645 // We're in the initial phase that associates signatures 646 // with the functions. Note this may be called multiple times 647 // in HOC chains like _s(hoc1(_s(hoc2(_s(actualFunction))))). 648 if (!savedType) { 649 // We're in the innermost call, so this is the actual type. 650 savedType = type; 651 hasCustomHooks = typeof getCustomHooks === 'function'; 652 } // Set the signature for all types (even wrappers!) in case 653 // they have no signatures of their own. This is to prevent 654 // problems like https://github.com/facebook/react/issues/20417. 655 if (type != null && (typeof type === 'function' || typeof type === 'object')) { 656 setSignature(type, key, forceReset, getCustomHooks); 657 } 658 return type; 659 } else { 660 // We're in the _s() call without arguments, which means 661 // this is the time to collect custom Hook signatures. 662 // Only do this once. This path is hot and runs *inside* every render! 663 if (!didCollectHooks && hasCustomHooks) { 664 didCollectHooks = true; 665 collectCustomHooksForSignature(savedType); 666 } 667 } 668 }; 669 } 670 } 671 function isLikelyComponentType(type) { 672 { 673 switch(typeof type){ 674 case 'function': 675 { 676 // First, deal with classes. 677 if (type.prototype != null) { 678 if (type.prototype.isReactComponent) { 679 // React class. 680 return true; 681 } 682 var ownNames = Object.getOwnPropertyNames(type.prototype); 683 if (ownNames.length > 1 || ownNames[0] !== 'constructor') { 684 // This looks like a class. 685 return false; 686 } // eslint-disable-next-line no-proto 687 if (type.prototype.__proto__ !== Object.prototype) { 688 // It has a superclass. 689 return false; 690 } // Pass through. 691 // This looks like a regular function with empty prototype. 692 } // For plain functions and arrows, use name as a heuristic. 693 var name = type.name || type.displayName; 694 return typeof name === 'string' && /^[A-Z]/.test(name); 695 } 696 case 'object': 697 { 698 if (type != null) { 699 switch(getProperty(type, '$$typeof')){ 700 case REACT_FORWARD_REF_TYPE: 701 case REACT_MEMO_TYPE: 702 // Definitely React components. 703 return true; 704 default: 705 return false; 706 } 707 } 708 return false; 709 } 710 default: 711 { 712 return false; 713 } 714 } 715 } 716 } 717 exports._getMountedRootCount = _getMountedRootCount; 718 exports.collectCustomHooksForSignature = collectCustomHooksForSignature; 719 exports.createSignatureFunctionForTransform = createSignatureFunctionForTransform; 720 exports.findAffectedHostInstances = findAffectedHostInstances; 721 exports.getFamilyByID = getFamilyByID; 722 exports.getFamilyByType = getFamilyByType; 723 exports.hasUnrecoverableErrors = hasUnrecoverableErrors; 724 exports.injectIntoGlobalHook = injectIntoGlobalHook; 725 exports.isLikelyComponentType = isLikelyComponentType; 726 exports.performReactRefresh = performReactRefresh; 727 exports.register = register; 728 exports.setSignature = setSignature; 729 })(); 730} 731}), 732"[project]/node_modules/next/dist/compiled/react-refresh/runtime.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports
732) => { 733"use strict"; 734 735var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)"); 736'use strict'; 737if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 738; 739else { 740 module.exports = __turbopack_context__.r("[project]/node_modules/next/dist/compiled/react-refresh/cjs/react-refresh-runtime.development.js [app-client] (ecmascript)"); 741} 742}), 743"[project]/node_modules/next/dist/compiled/@next/react-refresh-utils/dist/internal/helpers.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => { 744"use strict"; 745 746/** 747 * MIT License 748 * 749 * Copyright (c) Facebook, Inc. and its affiliates. 750 * 751 * Permission is hereby granted, free of charge, to any person obtaining a copy 752 * of this software and associated documentation files (the "Software"), to deal 753 * in the Software without restriction, including without limitation the rights 754 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 755 * copies of the Software, and to permit persons to whom the Software is 756 * furnished to do so, subject to the following conditions: 757 * 758 * The above copyright notice and this permission notice shall be included in all 759 * copies or substantial portions of the Software. 760 * 761 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 762 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 763 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 764 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 765 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 766 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 767 * SOFTWARE. 768 */ var __importDefault = /*TURBOPACK member replacement*/ __turbopack_context__.e && /*TURBOPACK member replacement*/ __turbopack_context__.e.__importDefault || function(mod) { 769 return mod && mod.__esModule ? mod : { 770 "default": mod 771 }; 772}; 773Object.defineProperty(exports, "__esModule", { 774 value: true 775}); 776// This file is copied from the Metro JavaScript bundler, with minor tweaks for 777// webpack 4 compatibility. 778// 779// https://github.com/facebook/metro/blob/d6b9685c730d0d63577db40f41369157f28dfa3a/packages/metro/src/lib/polyfills/require.js 780const runtime_1 = __importDefault(__turbopack_context__.r("[project]/node_modules/next/dist/compiled/react-refresh/runtime.js [app-client] (ecmascript)")); 781function isSafeExport(key) { 782 return key === '__esModule' || key === '__N_SSG' || key === '__N_SSP' || // TODO: remove this key from page config instead of allow listing it 783 key === 'config'; 784} 785function registerExportsForReactRefresh(moduleExports, moduleID) { 786 runtime_1.default.register(moduleExports, moduleID + ' %exports%'); 787 if (moduleExports == null || typeof moduleExports !== 'object') { 788 // Exit if we can't iterate over exports. 789 // (This is important for legacy environments.) 790 return; 791 } 792 for(var key in moduleExports){ 793 if (isSafeExport(key)) { 794 continue; 795 } 796 try { 797 var exportValue = moduleExports[key]; 798 } catch (_a) { 799 continue; 800 } 801 var typeID = moduleID + ' %exports% ' + key; 802 runtime_1.default.register(exportValue, typeID); 803 } 804} 805function getRefreshBoundarySignature(moduleExports) { 806 var signature = []; 807 signature.push(runtime_1.default.getFamilyByType(moduleExports)); 808 if (moduleExports == null || typeof moduleExports !== 'object') { 809 // Exit if we can't iterate over exports. 810 // (This is important for legacy environments.) 811 return signature; 812 } 813 for(var key in moduleExports){ 814 if (isSafeExport(key)) { 815 continue; 816 } 817 try { 818 var exportValue = moduleExports[key]; 819 } catch (_a) { 820 continue; 821 } 822 signature.push(key); 823 signature.push(runtime_1.default.getFamilyByType(exportValue)); 824 } 825 return signature; 826} 827function isReactRefreshBoundary(moduleExports) { 828 if (runtime_1.default.isLikelyComponentType(moduleExports)) { 829 return true; 830 } 831 if (moduleExports == null || typeof moduleExports !== 'object') { 832 // Exit if we can't iterate over exports. 833 return false;
834 } 835 var hasExports = false; 836 var areAllExportsComponents = true; 837 for(var key in moduleExports){ 838 hasExports = true; 839 if (isSafeExport(key)) { 840 continue; 841 } 842 try { 843 var exportValue = moduleExports[key]; 844 } catch (_a) { 845 // This might fail due to circular dependencies 846 return false; 847 } 848 if (!runtime_1.default.isLikelyComponentType(exportValue)) { 849 areAllExportsComponents = false; 850 } 851 } 852 return hasExports && areAllExportsComponents; 853} 854function shouldInvalidateReactRefreshBoundary(prevSignature, nextSignature) { 855 if (prevSignature.length !== nextSignature.length) { 856 return true; 857 } 858 for(var i = 0; i < nextSignature.length; i++){ 859 if (prevSignature[i] !== nextSignature[i]) { 860 return true; 861 } 862 } 863 return false; 864} 865var isUpdateScheduled = false; 866// This function aggregates updates from multiple modules into a single React Refresh call. 867function scheduleUpdate() { 868 if (isUpdateScheduled) { 869 return; 870 } 871 isUpdateScheduled = true; 872 function canApplyUpdate(status) { 873 return status === 'idle'; 874 } 875 function applyUpdate() { 876 isUpdateScheduled = false; 877 try { 878 runtime_1.default.performReactRefresh(); 879 } catch (err) { 880 console.warn('Warning: Failed to re-render. We will retry on the next Fast Refresh event.\n' + err); 881 } 882 } 883 if (canApplyUpdate(module.hot.status())) { 884 // Apply update on the next tick. 885 Promise.resolve().then(()=>{ 886 applyUpdate(); 887 }); 888 return; 889 } 890 const statusHandler = (status)=>{ 891 if (canApplyUpdate(status)) { 892 module.hot.removeStatusHandler(statusHandler); 893 applyUpdate(); 894 } 895 }; 896 // Apply update once the HMR runtime's status is idle. 897 module.hot.addStatusHandler(statusHandler); 898} 899// Needs to be compatible with IE11 900exports.default = { 901 registerExportsForReactRefresh: registerExportsForReactRefresh, 902 isReactRefreshBoundary: isReactRefreshBoundary, 903 shouldInvalidateReactRefreshBoundary: shouldInvalidateReactRefreshBoundary, 904 getRefreshBoundarySignature: getRefreshBoundarySignature, 905 scheduleUpdate: scheduleUpdate 906}; //# sourceMappingURL=helpers.js.map 907}), 908"[project]/node_modules/next/dist/compiled/@next/react-refresh-utils/dist/runtime.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => { 909"use strict"; 910 911var __importDefault = /*TURBOPACK member replacement*/ __turbopack_context__.e && /*TURBOPACK member replacement*/ __turbopack_context__.e.__importDefault || function(mod) { 912 return mod && mod.__esModule ? mod : { 913 "default": mod 914 }; 915}; 916Object.defineProperty(exports, "__esModule", { 917 value: true 918}); 919const runtime_1 = __importDefault(__turbopack_context__.r("[project]/node_modules/next/dist/compiled/react-refresh/runtime.js [app-client] (ecmascript)")); 920const helpers_1 = __importDefault(__turbopack_context__.r("[project]/node_modules/next/dist/compiled/@next/react-refresh-utils/dist/internal/helpers.js [app-client] (ecmascript)")); 921// Hook into ReactDOM initialization 922runtime_1.default.injectIntoGlobalHook(self); 923// Register global helpers 924self.$RefreshHelpers$ = helpers_1.default; 925// Register a helper for module execution interception 926self.$RefreshInterceptModuleExecution$ = function(webpackModuleId) { 927 var prevRefreshReg = self.$RefreshReg$; 928 var prevRefreshSig = self.$RefreshSig$; 929 self.$RefreshReg$ = function(type, id) { 930 runtime_1.default.register(type, webpackModuleId + ' ' + id); 931 }; 932 self.$RefreshSig$ = runtime_1.default.createSignatureFunctionForTransform; 933 // Modeled after `useEffect` cleanup pattern: 934 // https://react.dev/learn/synchronizing-with-effects#step-3-add-cleanup-if-needed 935 return function() { 936 self.$RefreshReg$ = prevRefreshReg; 937 self.$RefreshSig$ = prevRefreshSig; 938 }; 939}; //# sourceMappingURL=runtime.js.map 940}), 941"[project]/node_modules/next/dist/compiled/react/cjs/react.development.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports
941) => { 942"use strict"; 943 944var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)"); 945/** 946 * @license React 947 * react.development.js 948 * 949 * Copyright (c) Meta Platforms, Inc. and affiliates. 950 * 951 * This source code is licensed under the MIT license found in the 952 * LICENSE file in the root directory of this source tree. 953 */ "use strict"; 954"production" !== ("TURBOPACK compile-time value", "development") && function() { 955 function defineDeprecationWarning(methodName, info) { 956 Object.defineProperty(Component.prototype, methodName, { 957 get: function() { 958 console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]); 959 } 960 }); 961 } 962 function getIteratorFn(maybeIterable) { 963 if (null === maybeIterable || "object" !== typeof maybeIterable) return null; 964 maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"]; 965 return "function" === typeof maybeIterable ? maybeIterable : null; 966 } 967 function warnNoop(publicInstance, callerName) { 968 publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass"; 969 var warningKey = publicInstance + "." + callerName; 970 didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, publicInstance), didWarnStateUpdateForUnmountedComponent[warningKey] = !0); 971 } 972 function Component(props, context, updater) { 973 this.props = props; 974 this.context = context; 975 this.refs = emptyObject; 976 this.updater = updater || ReactNoopUpdateQueue; 977 } 978 function ComponentDummy() {} 979 function PureComponent(props, context, updater) { 980 this.props = props; 981 this.context = context; 982 this.refs = emptyObject; 983 this.updater = updater || ReactNoopUpdateQueue; 984 } 985 function noop() {} 986 function testStringCoercion(value) { 987 return "" + value; 988 } 989 function checkKeyStringCoercion(value) { 990 try { 991 testStringCoercion(value); 992 var JSCompiler_inline_result = !1; 993 } catch (e) { 994 JSCompiler_inline_result = !0; 995 } 996 if (JSCompiler_inline_result) { 997 JSCompiler_inline_result = console; 998 var JSCompiler_temp_const = JSCompiler_inline_result.error; 999 var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object"; 1000 JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0); 1001 return testStringCoercion(value); 1002 } 1003 } 1004 function getComponentNameFromType(type) { 1005 if (null == type) return null; 1006 if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null; 1007 if ("string" === typeof type) return type; 1008 switch(type){ 1009 case REACT_FRAGMENT_TYPE: 1010 return "Fragment"; 1011 case REACT_PROFILER_TYPE: 1012 return "Profiler"; 1013 case REACT_STRICT_MODE_TYPE: 1014 return "StrictMode"; 1015 case REACT_SUSPENSE_TYPE: 1016 return "Suspense"; 1017 case REACT_SUSPENSE_LIST_TYPE: 1018 return "SuspenseList"; 1019 case REACT_ACTIVITY_TYPE: 1020 return "Activity"; 1021 case REACT_VIEW_TRANSITION_TYPE: 1022 return "ViewTransition"; 1023 } 1024 if ("object" === typeof type) switch("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof){ 1025 case REACT_PORTAL_TYPE: 1026 return "Portal"; 1027 case REACT_CONTEXT_TYPE: 1028 return type.displayName || "Context"; 1029 case REACT_CONSUMER_TYPE: 1030 return (type._context.displayName || "Context") + ".Consumer"; 1031 case REACT_FORWARD_REF_TYPE: 1032 var innerType = type.render; 1033 type = type.displayName; 1034 type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"); 1035 return type; 1036 case REACT_MEMO_TYPE: 1037 return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo"; 1038 case REACT_LAZY_TYPE: 1039 innerType = type._payload; 1040 type = type._init; 1041 try { 1042 return getComponentNameFromType(type(innerType)); 1043 } catch (x) {} 1044 } 1045 return null; 1046 } 1047 function getTaskName(type) { 1048 if (type === REACT_FRAGMENT_TYPE) return "<>"; 1049 if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE
1049) return "<...>"; 1050 try { 1051 var name = getComponentNameFromType(type); 1052 return name ? "<" + name + ">" : "<...>"; 1053 } catch (x) { 1054 return "<...>"; 1055 } 1056 } 1057 function getOwner() { 1058 var dispatcher = ReactSharedInternals.A; 1059 return null === dispatcher ? null : dispatcher.getOwner(); 1060 } 1061 function UnknownOwner() { 1062 return Error("react-stack-top-frame"); 1063 } 1064 function hasValidKey(config) { 1065 if (hasOwnProperty.call(config, "key")) { 1066 var getter = Object.getOwnPropertyDescriptor(config, "key").get; 1067 if (getter && getter.isReactWarning) return !1; 1068 } 1069 return void 0 !== config.key; 1070 } 1071 function defineKeyPropWarningGetter(props, displayName) { 1072 function warnAboutAccessingKey() { 1073 specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName)); 1074 } 1075 warnAboutAccessingKey.isReactWarning = !0; 1076 Object.defineProperty(props, "key", { 1077 get: warnAboutAccessingKey, 1078 configurable: !0 1079 }); 1080 } 1081 function elementRefGetterWithDeprecationWarning() { 1082 var componentName = getComponentNameFromType(this.type); 1083 didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release.")); 1084 componentName = this.props.ref; 1085 return void 0 !== componentName ? componentName : null; 1086 } 1087 function ReactElement(type, key, props, owner, debugStack, debugTask) { 1088 var refProp = props.ref; 1089 type = { 1090 $$typeof: REACT_ELEMENT_TYPE, 1091 type: type, 1092 key: key, 1093 props: props, 1094 _owner: owner 1095 }; 1096 null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", { 1097 enumerable: !1, 1098 get: elementRefGetterWithDeprecationWarning 1099 }) : Object.defineProperty(type, "ref", { 1100 enumerable: !1, 1101 value: null 1102 }); 1103 type._store = {}; 1104 Object.defineProperty(type._store, "validated", { 1105 configurable: !1, 1106 enumerable: !1, 1107 writable: !0, 1108 value: 0 1109 }); 1110 Object.defineProperty(type, "_debugInfo", { 1111 configurable: !1, 1112 enumerable: !1, 1113 writable: !0, 1114 value: null 1115 }); 1116 Object.defineProperty(type, "_debugStack", { 1117 configurable: !1, 1118 enumerable: !1, 1119 writable: !0, 1120 value: debugStack 1121 }); 1122 Object.defineProperty(type, "_debugTask", { 1123 configurable: !1, 1124 enumerable: !1, 1125 writable: !0, 1126 value: debugTask 1127 }); 1128 Object.freeze && (Object.freeze(type.props), Object.freeze(type)); 1129 return type; 1130 } 1131 function cloneAndReplaceKey(oldElement, newKey) { 1132 newKey = ReactElement(oldElement.type, newKey, oldElement.props, oldElement._owner, oldElement._debugStack, oldElement._debugTask); 1133 oldElement._store && (newKey._store.validated = oldElement._store.validated); 1134 return newKey; 1135 } 1136 function validateChildKeys(node) { 1137 isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1)); 1138 } 1139 function isValidElement(object) { 1140 return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE; 1141 } 1142 function escape(key) { 1143 var escaperLookup = { 1144 "=": "=0", 1145 ":": "=2" 1146 }; 1147 return "$" + key.replace(/[=:]/g, function(match) { 1148 return escaperLookup[match]; 1149 }); 1150 } 1151 function getElementKey(element, index) { 1152 return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36); 1153 } 1154 function resolveThenable(thenable) { 1155 switch(thenable.status){ 1156 case "fulfilled": 1157 return thenable.value; 1158 case "rejected": 1159 throw thenable.reason; 1160 default: 1161 switch("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(function(fulfilledValue) { 1162 "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue); 1163 }, function(error) { 1164 "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error); 1165 })), thenable.status){ 1166 case "fulfilled": 1167 return thenable.value; 1168 case "rejected": 1169 throw thenable.reason; 1170 } 1171 } 1172 throw thenable; 1173 } 1174 function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) { 1175 var type = typeof children; 1176 if ("undefined" === type || "boolean" === type) children = null; 1177 var invokeCallback = !1; 1178 if (null === children) invokeCallback = !0; 1179 else switch(type){ 1180 case "bigint": 1181 case "string": 1182 case "number": 1183 invokeCallback = !0; 1184 break; 1185 case "object": 1186 switch(children.$$typeof){ 1187 case REACT_ELEMENT_TYPE: 1188 case REACT_PORTAL_TYPE: 1189 invokeCallback = !0; 1190 break; 1191 case REACT_LAZY_TYPE: 1192 return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback); 1193 } 1194 } 1195 if (invokeCallback) { 1196 invokeCallback = children; 1197 callback = callback(invokeCallback); 1198 var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar; 1199 isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) { 1200 return c; 1201 })) : null != callback && (isValidElement(callback) && (null != callback.key && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(callback, escapedPrefix + (null == callback.key || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + childKey), "" !== nameSoFar && null != invokeCallback && isValidElement(invokeCallback) && null == invokeCallback.key && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback)); 1202 return 1; 1203 } 1204 invokeCallback = 0; 1205 childKey = "" === nameSoFar ? "." : nameSoFar + ":"; 1206 if (isArrayImpl(children)) for(var i = 0; i < children.length; i++)nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback); 1207 else if (i = getIteratorFn(children), "function" === typeof i) for(i === children.entries && (didWarnAboutMaps || console.warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = !0), children = i.call(children), i = 0; !(nameSoFar = children.next()).done;)nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback); 1208 else if ("object" === type) { 1209 if ("function" === typeof children.then) return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback); 1210 array = String(children); 1211 throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead."); 1212 } 1213 return invokeCallback; 1214 } 1215 function mapChildren(children, func, context) { 1216 if (null == children) return children; 1217 var result = [], count = 0; 1218 mapIntoArray(children, result, "", "", function(child) { 1219 return func.call(context, child, count++); 1220 }); 1221 return result; 1222 } 1223 function lazyInitializer(payload) { 1224 if (-1 === payload._status) { 1225 var resolveDebugValue = null, rejectDebugValue = null, ioInfo = payload._ioInfo; 1226 null != ioInfo && (ioInfo.start = ioInfo.end = performance.now(), ioInfo.value = new Promise(function(resolve, reject) { 1227 resolveDebugValue = resolve; 1228 rejectDebugValue = reject; 1229 })); 1230 ioInfo = payload._result; 1231 var thenable = ioInfo(); 1232 thenable.then(function(moduleObject) { 1233 if (0 === payload._status || -1 === payload._status) { 1234 payload._status = 1; 1235 payload._result = moduleObject; 1236 var _ioInfo = payload._ioInfo; 1237 if (null != _ioInfo) { 1238 _ioInfo.end = performance.now(); 1239 var debugValue = null == moduleObject ? void 0 : moduleObject.default; 1240 resolveDebugValue(debugValue); 1241 _ioInfo.value.status = "fulfilled"; 1242 _ioInfo.value.value = debugValue; 1243 } 1244 void 0 === thenable.status && (thenable.status = "fulfilled", thenable.value = moduleObject); 1245 } 1246 }, function(error) { 1247 if (0 === payload._status || -1 === payload._status) { 1248 payload._status = 2; 1249 payload._result = error; 1250 var _ioInfo2 = payload._ioInfo; 1251 null != _ioInfo2 && (_ioInfo2.end = performance.now(), _ioInfo2.value.then(noop, noop), rejectDebugValue(error), _ioInfo2.value.status = "rejected", _ioInfo2.value.reason = error); 1252 void 0 === thenable.status && (thenable.status = "rejected", thenable.reason = error); 1253 } 1254 }); 1255 ioInfo = payload._ioInfo; 1256 if (null != ioInfo) { 1257 var displayName = thenable.displayName; 1258 "string" === typeof displayName && (ioInfo.name = displayName); 1259 } 1260 -1 === payload._status && (payload._status = 0, payload._result = thenable); 1261 } 1262 if (1 === payload._status) return ioInfo = payload._result, void 0 === ioInfo && console.error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?", ioInfo), "default" in ioInfo || console.error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))", ioInfo), ioInfo.default; 1263 throw payload._result; 1264 } 1265 function resolveDispatcher() { 1266 var dispatcher = ReactSharedInternals.H; 1267 null === dispatcher && console.error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.");
1268 return dispatcher; 1269 } 1270 function releaseAsyncTransition() { 1271 ReactSharedInternals.asyncTransitions--; 1272 } 1273 function startTransition(scope) { 1274 var prevTransition = ReactSharedInternals.T, currentTransition = {}; 1275 currentTransition.types = null !== prevTransition ? prevTransition.types : null; 1276 currentTransition._updatedFibers = new Set(); 1277 ReactSharedInternals.T = currentTransition; 1278 try { 1279 var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S; 1280 null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue); 1281 "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError)); 1282 } catch (error) { 1283 reportGlobalError(error); 1284 } finally{ 1285 null === prevTransition && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.")), null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error("We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition; 1286 } 1287 } 1288 function addTransitionType(type) { 1289 var transition = ReactSharedInternals.T; 1290 if (null !== transition) { 1291 var transitionTypes = transition.types; 1292 null === transitionTypes ? transition.types = [ 1293 type 1294 ] : -1 === transitionTypes.indexOf(type) && transitionTypes.push(type); 1295 } else 0 === ReactSharedInternals.asyncTransitions && console.error("addTransitionType can only be called inside a `startTransition()` callback. It must be associated with a specific Transition."), startTransition(addTransitionType.bind(null, type)); 1296 } 1297 function enqueueTask(task) { 1298 if (null === enqueueTaskImpl) try { 1299 var requireString = ("require" + Math.random()).slice(0, 7); 1300 enqueueTaskImpl = (module && module[requireString]).call(module, "timers").setImmediate; 1301 } catch (_err) { 1302 enqueueTaskImpl = function(callback) { 1303 !1 === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = !0, "undefined" === typeof MessageChannel && console.error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning.")); 1304 var channel = new MessageChannel(); 1305 channel.port1.onmessage = callback; 1306 channel.port2.postMessage(void 0); 1307 }; 1308 } 1309 return enqueueTaskImpl(task); 1310 } 1311 function aggregateErrors(errors) { 1312 return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0]; 1313 } 1314 function popActScope(prevActQueue, prevActScopeDepth) { 1315 prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "); 1316 actScopeDepth = prevActScopeDepth; 1317 } 1318 function recursivelyFlushAsyncActWork(returnValue, resolve, reject) { 1319 var queue = ReactSharedInternals.actQueue; 1320 if (null !== queue) if (0 !== queue.length) try { 1321 flushActQueue(queue); 1322 enqueueTask(function() { 1323 return recursivelyFlushAsyncActWork(returnValue, resolve, reject); 1324 }); 1325 return; 1326 } catch (error) { 1327 ReactSharedInternals.thrownErrors.push(error); 1328 } 1329 else ReactSharedInternals.actQueue = null; 1330 0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue); 1331 } 1332 function flushActQueue(queue) { 1333 if (!isFlushing) { 1334 isFlushing = !0; 1335 var i = 0; 1336 try { 1337 for(; i < queue.length; i++){ 1338 var callback = queue[i]; 1339 do { 1340 ReactSharedInternals.didUsePromise = !1; 1341 var continuation = callback(!1); 1342 if (null !== continuation) { 1343 if (ReactSharedInternals.didUsePromise) { 1344 queue[i] = callback; 1345 queue.splice(0, i); 1346 return; 1347 } 1348 callback = continuation; 1349 } else break; 1350 }while (1) 1351 } 1352 queue.length = 0; 1353 } catch (error) { 1354 queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error); 1355 } finally{ 1356 isFlushing = !1; 1357 } 1358 } 1359 } 1360 "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error()); 1361 var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = { 1362 isMounted: function() { 1363 return !1; 1364 }, 1365 enqueueForceUpdate: function(publicInstance) { 1366 warnNoop(publicInstance, "forceUpdate"); 1367 }, 1368 enqueueReplaceState: function(publicInstance) { 1369 warnNoop(publicInstance, "replaceState"); 1370 }, 1371 enqueueSetState: function(publicInstance) { 1372 warnNoop(publicInstance, "setState"); 1373 } 1374 }, assign = Object.assign, emptyObject = {};
1375 Object.freeze(emptyObject); 1376 Component.prototype.isReactComponent = {}; 1377 Component.prototype.setState = function(partialState, callback) { 1378 if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState) throw Error("takes an object of state variables to update or a function which returns an object of state variables."); 1379 this.updater.enqueueSetState(this, partialState, callback, "setState"); 1380 }; 1381 Component.prototype.forceUpdate = function(callback) { 1382 this.updater.enqueueForceUpdate(this, callback, "forceUpdate"); 1383 }; 1384 var deprecatedAPIs = { 1385 isMounted: [ 1386 "isMounted", 1387 "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks." 1388 ], 1389 replaceState: [ 1390 "replaceState", 1391 "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)." 1392 ] 1393 }; 1394 for(fnName in deprecatedAPIs)deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); 1395 ComponentDummy.prototype = Component.prototype; 1396 deprecatedAPIs = PureComponent.prototype = new ComponentDummy(); 1397 deprecatedAPIs.constructor = PureComponent; 1398 assign(deprecatedAPIs, Component.prototype); 1399 deprecatedAPIs.isPureReactComponent = !0; 1400 var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = { 1401 H: null, 1402 A: null, 1403 T: null, 1404 S: null, 1405 actQueue: null, 1406 asyncTransitions: 0, 1407 isBatchingLegacy: !1, 1408 didScheduleLegacyUpdate: !1, 1409 didUsePromise: !1, 1410 thrownErrors: [], 1411 getCurrentStack: null, 1412 recentlyCreatedOwnerStacks: 0 1413 }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() { 1414 return null; 1415 }; 1416 deprecatedAPIs = { 1417 react_stack_bottom_frame: function(callStackForError) { 1418 return callStackForError(); 1419 } 1420 }; 1421 var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime; 1422 var didWarnAboutElementRef = {}; 1423 var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(deprecatedAPIs, UnknownOwner)(); 1424 var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner)); 1425 var didWarnAboutMaps = !1, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = "function" === typeof reportError ? reportError : function(error) { 1426 if ("object" === typeof window && "function" === typeof window.ErrorEvent) { 1427 var event = new window.ErrorEvent("error", { 1428 bubbles: !0, 1429 cancelable: !0, 1430 message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error), 1431 error: error 1432 }); 1433 if (!window.dispatchEvent(event)) return; 1434 } else if ("object" === typeof __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__["default"] && "function" === typeof __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__["default"].emit) { 1435 __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__["default"].emit("uncaughtException", error); 1436 return; 1437 } 1438 console.error(error); 1439 }, didWarnAboutMessageChannel = !1, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = !1, isFlushing = !1, queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function(callback) { 1440 queueMicrotask(function() { 1441 return queueMicrotask(callback); 1442 }); 1443 } : enqueueTask; 1444 deprecatedAPIs = Object.freeze({ 1445 __proto__: null, 1446 c: function(size) { 1447 return resolveDispatcher().useMemoCache(size); 1448 } 1449 }); 1450 var fnName = { 1451 map: mapChildren,
1452 forEach: function(children, forEachFunc, forEachContext) { 1453 mapChildren(children, function() { 1454 forEachFunc.apply(this, arguments); 1455 }, forEachContext); 1456 }, 1457 count: function(children) { 1458 var n = 0; 1459 mapChildren(children, function() { 1460 n++; 1461 }); 1462 return n; 1463 }, 1464 toArray: function(children) { 1465 return mapChildren(children, function(child) { 1466 return child; 1467 }) || []; 1468 }, 1469 only: function(children) { 1470 if (!isValidElement(children)) throw Error("React.Children.only expected to receive a single React element child."); 1471 return children; 1472 } 1473 }; 1474 exports.Activity = REACT_ACTIVITY_TYPE; 1475 exports.Children = fnName; 1476 exports.Component = Component; 1477 exports.Fragment = REACT_FRAGMENT_TYPE; 1478 exports.Profiler = REACT_PROFILER_TYPE; 1479 exports.PureComponent = PureComponent; 1480 exports.StrictMode = REACT_STRICT_MODE_TYPE; 1481 exports.Suspense = REACT_SUSPENSE_TYPE; 1482 exports.ViewTransition = REACT_VIEW_TRANSITION_TYPE; 1483 exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals; 1484 exports.__COMPILER_RUNTIME = deprecatedAPIs; 1485 exports.act = function(callback) { 1486 var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth; 1487 actScopeDepth++; 1488 var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = !1; 1489 try { 1490 var result = callback(); 1491 } catch (error) { 1492 ReactSharedInternals.thrownErrors.push(error); 1493 } 1494 if (0 < ReactSharedInternals.thrownErrors.length) throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback; 1495 if (null !== result && "object" === typeof result && "function" === typeof result.then) { 1496 var thenable = result; 1497 queueSeveralMicrotasks(function() { 1498 didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);")); 1499 }); 1500 return { 1501 then: function(resolve, reject) { 1502 didAwaitActCall = !0; 1503 thenable.then(function(returnValue) { 1504 popActScope(prevActQueue, prevActScopeDepth); 1505 if (0 === prevActScopeDepth) { 1506 try { 1507 flushActQueue(queue), enqueueTask(function() { 1508 return recursivelyFlushAsyncActWork(returnValue, resolve, reject); 1509 }); 1510 } catch (error$0) { 1511 ReactSharedInternals.thrownErrors.push(error$0); 1512 } 1513 if (0 < ReactSharedInternals.thrownErrors.length) { 1514 var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors); 1515 ReactSharedInternals.thrownErrors.length = 0; 1516 reject(_thrownError); 1517 } 1518 } else resolve(returnValue); 1519 }, function(error) { 1520 popActScope(prevActQueue, prevActScopeDepth); 1521 0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error); 1522 }); 1523 } 1524 }; 1525 } 1526 var returnValue$jscomp$0 = result; 1527 popActScope(prevActQueue, prevActScopeDepth); 1528 0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function() { 1529 didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("A component suspended inside an `act` scope, but the `act` c
1529all was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)")); 1530 }), ReactSharedInternals.actQueue = null); 1531 if (0 < ReactSharedInternals.thrownErrors.length) throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback; 1532 return { 1533 then: function(resolve, reject) { 1534 didAwaitActCall = !0; 1535 0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() { 1536 return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject); 1537 })) : resolve(returnValue$jscomp$0); 1538 } 1539 }; 1540 }; 1541 exports.addTransitionType = addTransitionType; 1542 exports.cache = function(fn) { 1543 return function() { 1544 return fn.apply(null, arguments); 1545 }; 1546 }; 1547 exports.cacheSignal = function() { 1548 return null; 1549 }; 1550 exports.captureOwnerStack = function() { 1551 var getCurrentStack = ReactSharedInternals.getCurrentStack; 1552 return null === getCurrentStack ? null : getCurrentStack(); 1553 }; 1554 exports.cloneElement = function(element, config, children) { 1555 if (null === element || void 0 === element) throw Error("The argument must be a React element, but you passed " + element + "."); 1556 var props = assign({}, element.props), key = element.key, owner = element._owner; 1557 if (null != config) { 1558 var JSCompiler_inline_result; 1559 a: { 1560 if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(config, "ref").get) && JSCompiler_inline_result.isReactWarning) { 1561 JSCompiler_inline_result = !1; 1562 break a; 1563 } 1564 JSCompiler_inline_result = void 0 !== config.ref; 1565 } 1566 JSCompiler_inline_result && (owner = getOwner()); 1567 hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key); 1568 for(propName in config)!hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]); 1569 } 1570 var propName = arguments.length - 2; 1571 if (1 === propName) props.children = children; 1572 else if (1 < propName) { 1573 JSCompiler_inline_result = Array(propName); 1574 for(var i = 0; i < propName; i++)JSCompiler_inline_result[i] = arguments[i + 2]; 1575 props.children = JSCompiler_inline_result; 1576 } 1577 props = ReactElement(element.type, key, props, owner, element._debugStack, element._debugTask); 1578 for(key = 2; key < arguments.length; key++)validateChildKeys(arguments[key]); 1579 return props; 1580 }; 1581 exports.createContext = function(defaultValue) { 1582 defaultValue = { 1583 $$typeof: REACT_CONTEXT_TYPE, 1584 _currentValue: defaultValue, 1585 _currentValue2: defaultValue, 1586 _threadCount: 0, 1587 Provider: null, 1588 Consumer: null 1589 }; 1590 defaultValue.Provider = defaultValue; 1591 defaultValue.Consumer = { 1592 $$typeof: REACT_CONSUMER_TYPE, 1593 _context: defaultValue 1594 }; 1595 defaultValue._currentRenderer = null; 1596 defaultValue._currentRenderer2 = null; 1597 return defaultValue; 1598 }; 1599 exports.createElement = function(type, config, children) { 1600 for(var i = 2; i < arguments.length; i++)validateChildKeys(arguments[i]); 1601 var propName; 1602 i = {}; 1603 var key = null; 1604 if (null != config) for(propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = !0, console.warn("Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform")), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config)hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (i[propName] = config[propName]); 1605 var childrenLength = arguments.length - 2; 1606 if (1 === childrenLength) i.children = children; 1607 else if (1 < childrenLength) { 1608 for(var childArray = Array(childrenLength), _i = 0; _i < childrenLength; _i++)childArray[_i] = arguments[_i + 2];
1609 Object.freeze && Object.freeze(childArray); 1610 i.children = childArray; 1611 } 1612 if (type && type.defaultProps) for(propName in childrenLength = type.defaultProps, childrenLength)void 0 === i[propName] && (i[propName] = childrenLength[propName]); 1613 key && defineKeyPropWarningGetter(i, "function" === typeof type ? type.displayName || type.name || "Unknown" : type); 1614 (propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++) ? (childArray = Error.stackTraceLimit, Error.stackTraceLimit = 10, childrenLength = Error("react-stack-top-frame"), Error.stackTraceLimit = childArray) : childrenLength = unknownOwnerDebugStack; 1615 return ReactElement(type, key, i, getOwner(), childrenLength, propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask); 1616 }; 1617 exports.createRef = function() { 1618 var refObject = { 1619 current: null 1620 }; 1621 Object.seal(refObject); 1622 return refObject; 1623 }; 1624 exports.forwardRef = function(render) { 1625 null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : "function" !== typeof render ? console.error("forwardRef requires a render function but was given %s.", null === render ? "null" : typeof render) : 0 !== render.length && 2 !== render.length && console.error("forwardRef render functions accept exactly two parameters: props and ref. %s", 1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."); 1626 null != render && null != render.defaultProps && console.error("forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"); 1627 var elementType = { 1628 $$typeof: REACT_FORWARD_REF_TYPE, 1629 render: render 1630 }, ownName; 1631 Object.defineProperty(elementType, "displayName", { 1632 enumerable: !1, 1633 configurable: !0, 1634 get: function() { 1635 return ownName; 1636 }, 1637 set: function(name) { 1638 ownName = name; 1639 render.name || render.displayName || (Object.defineProperty(render, "name", { 1640 value: name 1641 }), render.displayName = name); 1642 } 1643 }); 1644 return elementType; 1645 }; 1646 exports.isValidElement = isValidElement; 1647 exports.lazy = function(ctor) { 1648 ctor = { 1649 _status: -1, 1650 _result: ctor 1651 }; 1652 var lazyType = { 1653 $$typeof: REACT_LAZY_TYPE, 1654 _payload: ctor, 1655 _init: lazyInitializer 1656 }, ioInfo = { 1657 name: "lazy", 1658 start: -1, 1659 end: -1, 1660 value: null, 1661 owner: null, 1662 debugStack: Error("react-stack-top-frame"), 1663 debugTask: console.createTask ? console.createTask("lazy()") : null 1664 }; 1665 ctor._ioInfo = ioInfo; 1666 lazyType._debugInfo = [ 1667 { 1668 awaited: ioInfo 1669 } 1670 ]; 1671 return lazyType; 1672 }; 1673 exports.memo = function(type, compare) { 1674 null == type && console.error("memo: The first argument must be a component. Instead received: %s", null === type ? "null" : typeof type); 1675 compare = { 1676 $$typeof: REACT_MEMO_TYPE, 1677 type: type, 1678 compare: void 0 === compare ? null : compare 1679 }; 1680 var ownName; 1681 Object.defineProperty(compare, "displayName", { 1682 enumerable: !1, 1683 configurable: !0, 1684 get: function() { 1685 return ownName; 1686 }, 1687 set: function(name) { 1688 ownName = name; 1689 type.name || type.displayName || (Object.defineProperty(type, "name", { 1690 value: name 1691 }), type.displayName = name); 1692 } 1693 }); 1694 return compare; 1695 }; 1696 exports.startTransition = startTransition; 1697 exports.unstable_useCacheRefresh = function() { 1698 return resolveDispatcher().useCacheRefresh(); 1699 }; 1700 exports.use = function(usable) { 1701 return resolveDispatcher().use(usable); 1702 }; 1703 exports.useActionState = function(action, initialState, permalink) { 1704 return resolveDispatcher().useActionState(action, initialState, permalink); 1705 }; 1706 exports.useCallback = function(callback, deps) { 1707 return resolveDispatcher().useCallback(callback, deps); 1708 }; 1709 exports.useContext = function(Context) { 1710 var dispatcher = resolveDispatcher(); 1711 Context.$$typeof === REACT_CONSUMER_TYPE && console.error("Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?");
1712 return dispatcher.useContext(Context); 1713 }; 1714 exports.useDebugValue = function(value, formatterFn) { 1715 return resolveDispatcher().useDebugValue(value, formatterFn); 1716 }; 1717 exports.useDeferredValue = function(value, initialValue) { 1718 return resolveDispatcher().useDeferredValue(value, initialValue); 1719 }; 1720 exports.useEffect = function(create, deps) { 1721 null == create && console.warn("React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"); 1722 return resolveDispatcher().useEffect(create, deps); 1723 }; 1724 exports.useEffectEvent = function(callback) { 1725 return resolveDispatcher().useEffectEvent(callback); 1726 }; 1727 exports.useId = function() { 1728 return resolveDispatcher().useId(); 1729 }; 1730 exports.useImperativeHandle = function(ref, create, deps) { 1731 return resolveDispatcher().useImperativeHandle(ref, create, deps); 1732 }; 1733 exports.useInsertionEffect = function(create, deps) { 1734 null == create && console.warn("React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"); 1735 return resolveDispatcher().useInsertionEffect(create, deps); 1736 }; 1737 exports.useLayoutEffect = function(create, deps) { 1738 null == create && console.warn("React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"); 1739 return resolveDispatcher().useLayoutEffect(create, deps); 1740 }; 1741 exports.useMemo = function(create, deps) { 1742 return resolveDispatcher().useMemo(create, deps); 1743 }; 1744 exports.useOptimistic = function(passthrough, reducer) { 1745 return resolveDispatcher().useOptimistic(passthrough, reducer); 1746 }; 1747 exports.useReducer = function(reducer, initialArg, init) { 1748 return resolveDispatcher().useReducer(reducer, initialArg, init); 1749 }; 1750 exports.useRef = function(initialValue) { 1751 return resolveDispatcher().useRef(initialValue); 1752 }; 1753 exports.useState = function(initialState) { 1754 return resolveDispatcher().useState(initialState); 1755 }; 1756 exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) { 1757 return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot); 1758 }; 1759 exports.useTransition = function() { 1760 return resolveDispatcher().useTransition(); 1761 }; 1762 exports.version = "19.3.0-canary-f93b9fd4-20251217"; 1763 "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error()); 1764}(); 1765}), 1766"[project]/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => { 1767"use strict"; 1768 1769var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)"); 1770'use strict'; 1771if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 1772; 1773else { 1774 module.exports = __turbopack_context__.r("[project]/node_modules/next/dist/compiled/react/cjs/react.development.js [app-client] (ecmascript)"); 1775} 1776}), 1777"[project]/node_modules/next/dist/compiled/react/cjs/react-jsx-runtime.development.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => { 1778"use strict"; 1779 1780var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)"); 1781/** 1782 * @license React 1783 * react-jsx-runtime.development.js 1784 * 1785 * Copyright (c) Meta Platforms, Inc. and affiliates. 1786 * 1787 * This source code is licensed under the MIT license found in the 1788 * LICENSE file in the root directory of this source tree. 1789 */ "use strict"; 1790"production" !== ("TURBOPACK compile-time value", "development") && function() { 1791 function getComponentNameFromType(type) { 1792 if (null == type) return null; 1793 if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null; 1794 if ("string" === typeof type) return type; 1795 switch(type){ 1796 case REACT_FRAGMENT_TYPE: 1797 return "Fragment";
1798 case REACT_PROFILER_TYPE: 1799 return "Profiler"; 1800 case REACT_STRICT_MODE_TYPE: 1801 return "StrictMode"; 1802 case REACT_SUSPENSE_TYPE: 1803 return "Suspense"; 1804 case REACT_SUSPENSE_LIST_TYPE: 1805 return "SuspenseList"; 1806 case REACT_ACTIVITY_TYPE: 1807 return "Activity"; 1808 case REACT_VIEW_TRANSITION_TYPE: 1809 return "ViewTransition"; 1810 } 1811 if ("object" === typeof type) switch("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof){ 1812 case REACT_PORTAL_TYPE: 1813 return "Portal"; 1814 case REACT_CONTEXT_TYPE: 1815 return type.displayName || "Context"; 1816 case REACT_CONSUMER_TYPE: 1817 return (type._context.displayName || "Context") + ".Consumer"; 1818 case REACT_FORWARD_REF_TYPE: 1819 var innerType = type.render; 1820 type = type.displayName; 1821 type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"); 1822 return type; 1823 case REACT_MEMO_TYPE: 1824 return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo"; 1825 case REACT_LAZY_TYPE: 1826 innerType = type._payload; 1827 type = type._init; 1828 try { 1829 return getComponentNameFromType(type(innerType)); 1830 } catch (x) {} 1831 } 1832 return null; 1833 } 1834 function testStringCoercion(value) { 1835 return "" + value; 1836 } 1837 function checkKeyStringCoercion(value) { 1838 try { 1839 testStringCoercion(value); 1840 var JSCompiler_inline_result = !1; 1841 } catch (e) { 1842 JSCompiler_inline_result = !0; 1843 } 1844 if (JSCompiler_inline_result) { 1845 JSCompiler_inline_result = console; 1846 var JSCompiler_temp_const = JSCompiler_inline_result.error; 1847 var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object"; 1848 JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0); 1849 return testStringCoercion(value); 1850 } 1851 } 1852 function getTaskName(type) { 1853 if (type === REACT_FRAGMENT_TYPE) return "<>"; 1854 if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) return "<...>"; 1855 try { 1856 var name = getComponentNameFromType(type); 1857 return name ? "<" + name + ">" : "<...>"; 1858 } catch (x) { 1859 return "<...>"; 1860 } 1861 } 1862 function getOwner() { 1863 var dispatcher = ReactSharedInternals.A; 1864 return null === dispatcher ? null : dispatcher.getOwner(); 1865 } 1866 function UnknownOwner() { 1867 return Error("react-stack-top-frame"); 1868 } 1869 function hasValidKey(config) { 1870 if (hasOwnProperty.call(config, "key")) { 1871 var getter = Object.getOwnPropertyDescriptor(config, "key").get; 1872 if (getter && getter.isReactWarning) return !1; 1873 } 1874 return void 0 !== config.key; 1875 } 1876 function defineKeyPropWarningGetter(props, displayName) { 1877 function warnAboutAccessingKey() { 1878 specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName)); 1879 } 1880 warnAboutAccessingKey.isReactWarning = !0; 1881 Object.defineProperty(props, "key", { 1882 get: warnAboutAccessingKey, 1883 configurable: !0 1884 }); 1885 } 1886 function elementRefGetterWithDeprecationWarning() { 1887 var componentName = getComponentNameFromType(this.type); 1888 didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release.")); 1889 componentName = this.props.ref; 1890 return void 0 !== componentName ? componentName : null; 1891 } 1892 function ReactElement(type, key, props, owner, debugStack, debugTask) { 1893 var refProp = props.ref; 1894 type = { 1895 $$typeof: REACT_ELEMENT_TYPE, 1896 type: type, 1897 key: key, 1898 props: props, 1899 _owner: owner 1900 }; 1901 null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", { 1902 enumerable: !1, 1903 get: elementRefGetterWithDeprecationWarning 1904 }) : Object.defineProperty(type, "ref", { 1905 enumerable: !1, 1906 value: null 1907 }); 1908 type._store = {}; 1909 Object.defineProperty(type._store, "validated", { 1910 configurable: !1, 1911 enumerable: !1, 1912 writable: !0, 1913 value: 0 1914 }); 1915 Object.defineProperty(type, "_debugInfo", { 1916 configurable: !1, 1917 enumerable: !1, 1918 writable: !0, 1919 value: null 1920 }); 1921 Object.defineProperty(type, "_debugStack", { 1922 configurable: !1, 1923 enumerable: !1, 1924 writable: !0, 1925 value: debugStack 1926 }); 1927 Object.defineProperty(type, "_debugTask", { 1928 configurable: !1, 1929 enumerable: !1, 1930 writable: !0, 1931 value: debugTask 1932 }); 1933 Object.freeze && (Object.freeze(type.props), Object.freeze(type)); 1934 return type; 1935 } 1936 function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) { 1937 var children = config.children; 1938 if (void 0 !== children) if (isStaticChildren) if (isArrayImpl(children)) { 1939 for(isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)validateChildKeys(children[isStaticChildren]);
1940 Object.freeze && Object.freeze(children); 1941 } else console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."); 1942 else validateChildKeys(children); 1943 if (hasOwnProperty.call(config, "key")) { 1944 children = getComponentNameFromType(type); 1945 var keys = Object.keys(config).filter(function(k) { 1946 return "key" !== k; 1947 }); 1948 isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}"; 1949 didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error('A props object containing a "key" prop is being spread into JSX:\n let props = %s;\n <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n let props = %s;\n <%s key={someKey} {...props} />', isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = !0); 1950 } 1951 children = null; 1952 void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey); 1953 hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key); 1954 if ("key" in config) { 1955 maybeKey = {}; 1956 for(var propName in config)"key" !== propName && (maybeKey[propName] = config[propName]); 1957 } else maybeKey = config; 1958 children && defineKeyPropWarningGetter(maybeKey, "function" === typeof type ? type.displayName || type.name || "Unknown" : type); 1959 return ReactElement(type, children, maybeKey, getOwner(), debugStack, debugTask); 1960 } 1961 function validateChildKeys(node) { 1962 isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1)); 1963 } 1964 function isValidElement(object) { 1965 return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE; 1966 } 1967 var React = __turbopack_context__.r("[project]/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() { 1968 return null; 1969 }; 1970 React = { 1971 react_stack_bottom_frame: function(callStackForError) { 1972 return callStackForError(); 1973 } 1974 }; 1975 var specialPropKeyWarningShown; 1976 var didWarnAboutElementRef = {}; 1977 var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(React, UnknownOwner)(); 1978 var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner)); 1979 var didWarnAboutKeySpread = {}; 1980 exports.Fragment = REACT_FRAGMENT_TYPE; 1981 exports.jsx = function(type, config, maybeKey) { 1982 var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++; 1983 if (trackActualOwner) { 1984 var previousStackTraceLimit = Error.stackTraceLimit; 1985 Error.stackTraceLimit = 10; 1986 var debugStackDEV = Error("react-stack-top-frame"); 1987 Error.stackTraceLimit = previousStackTraceLimit; 1988 } else debugStackDEV = unknownOwnerDebugStack; 1989 return jsxDEVImpl(type, config, maybeKey, !1, debugStackDEV, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask); 1990 }; 1991 exports.jsxs = function(type, config, maybeKey) { 1992 var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++; 1993 if (trackActualOwner) { 1994 var previousStackTraceLimit = Error.stackTraceLimit; 1995 Error.stackTraceLimit = 10; 1996 var debugStackDEV = Error("react-stack-top-frame"); 1997 Error.stackTraceLimit = previousStackTraceLimit; 1998 } else debugStackDEV = unknownOwnerDebugStack; 1999 return jsxDEVImpl(type, config, maybeKey, !0, debugStackDEV, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask); 2000 }; 2001}(); 2002}), 2003"[project]/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports
2003) => { 2004"use strict"; 2005 2006var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)"); 2007'use strict'; 2008if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 2009; 2010else { 2011 module.exports = __turbopack_context__.r("[project]/node_modules/next/dist/compiled/react/cjs/react-jsx-runtime.development.js [app-client] (ecmascript)"); 2012} 2013}), 2014"[project]/node_modules/next/dist/compiled/safe-stable-stringify/index.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => { 2015 2016(function() { 2017 "use strict"; 2018 var e = { 2019 879: function(e, t) { 2020 const { hasOwnProperty: n } = Object.prototype; 2021 const r = configure(); 2022 r.configure = configure; 2023 r.stringify = r; 2024 r.default = r; 2025 t.stringify = r; 2026 t.configure = configure; 2027 e.exports = r; 2028 const i = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/; 2029 function strEscape(e) { 2030 if (e.length < 5e3 && !i.test(e)) { 2031 return `"${e}"`; 2032 } 2033 return JSON.stringify(e); 2034 } 2035 function sort(e, t) { 2036 if (e.length > 200 || t) { 2037 return e.sort(t); 2038 } 2039 for(let t = 1; t < e.length; t++){ 2040 const n = e[t]; 2041 let r = t; 2042 while(r !== 0 && e[r - 1] > n){ 2043 e[r] = e[r - 1]; 2044 r--; 2045 } 2046 e[r] = n; 2047 } 2048 return e; 2049 } 2050 const f = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Object.getPrototypeOf(new Int8Array)), Symbol.toStringTag).get; 2051 function isTypedArrayWithEntries(e) { 2052 return f.call(e) !== undefined && e.length !== 0; 2053 } 2054 function stringifyTypedArray(e, t, n) { 2055 if (e.length < n) { 2056 n = e.length; 2057 } 2058 const r = t === "," ? "" : " "; 2059 let i = `"0":${r}${e[0]}`; 2060 for(let f = 1; f < n; f++){ 2061 i += `${t}"${f}":${r}${e[f]}`; 2062 } 2063 return i; 2064 } 2065 function getCircularValueOption(e) { 2066 if (n.call(e, "circularValue")) { 2067 const t = e.circularValue; 2068 if (typeof t === "string") { 2069 return `"${t}"`; 2070 } 2071 if (t == null) { 2072 return t; 2073 } 2074 if (t === Error || t === TypeError) { 2075 return { 2076 toString () { 2077 throw new TypeError("Converting circular structure to JSON"); 2078 } 2079 }; 2080 } 2081 throw new TypeError('The "circularValue" argument must be of type string or the value null or undefined'); 2082 } 2083 return '"[Circular]"'; 2084 } 2085 function getDeterministicOption(e) { 2086 let t; 2087 if (n.call(e, "deterministic")) { 2088 t = e.deterministic; 2089 if (typeof t !== "boolean" && typeof t !== "function") { 2090 throw new TypeError('The "deterministic" argument must be of type boolean or comparator function'); 2091 } 2092 } 2093 return t === undefined ? true : t; 2094 } 2095 function getBooleanOption(e, t) { 2096 let r; 2097 if (n.call(e, t)) { 2098 r = e[t]; 2099 if (typeof r !== "boolean") { 2100 throw new TypeError(`The "${t}" argument must be of type boolean`); 2101 } 2102 } 2103 return r === undefined ? true : r; 2104 } 2105 function getPositiveIntegerOption(e, t) { 2106 let r; 2107 if (n.call(e, t)) { 2108 r = e[t]; 2109 if (typeof r !== "number") { 2110 throw new TypeError(`The "${t}" argument must be of type number`); 2111 } 2112 if (!Number.isInteger(r)) { 2113 throw new TypeError(`The "${t}" argument must be an integer`); 2114 } 2115 if (r < 1) { 2116 throw new RangeError(`The "${t}" argument must be >= 1`); 2117 } 2118 } 2119 return r === undefined ? Infinity : r; 2120 } 2121 function getItemCount(e) { 2122 if (e === 1) { 2123 return "1 item"; 2124 } 2125 return `${e} items`; 2126 } 2127 function getUniqueReplacerSet(e) { 2128 const t = new Set; 2129 for (const n of e){
2130 if (typeof n === "string" || typeof n === "number") { 2131 t.add(String(n)); 2132 } 2133 } 2134 return t; 2135 } 2136 function getStrictOption(e) { 2137 if (n.call(e, "strict")) { 2138 const t = e.strict; 2139 if (typeof t !== "boolean") { 2140 throw new TypeError('The "strict" argument must be of type boolean'); 2141 } 2142 if (t) { 2143 return (e)=>{ 2144 let t = `Object can not safely be stringified. Received type ${typeof e}`; 2145 if (typeof e !== "function") t += ` (${e.toString()})`; 2146 throw new Error(t); 2147 }; 2148 } 2149 } 2150 } 2151 function configure(e) { 2152 e = { 2153 ...e 2154 }; 2155 const t = getStrictOption(e); 2156 if (t) { 2157 if (e.bigint === undefined) { 2158 e.bigint = false; 2159 } 2160 if (!("circularValue" in e)) { 2161 e.circularValue = Error; 2162 } 2163 } 2164 const n = getCircularValueOption(e); 2165 const r = getBooleanOption(e, "bigint"); 2166 const i = getDeterministicOption(e); 2167 const f = typeof i === "function" ? i : undefined; 2168 const u = getPositiveIntegerOption(e, "maximumDepth"); 2169 const o = getPositiveIntegerOption(e, "maximumBreadth"); 2170 function stringifyFnReplacer(e, s, l, c, a, g) { 2171 let p = s[e]; 2172 if (typeof p === "object" && p !== null && typeof p.toJSON === "function") { 2173 p = p.toJSON(e); 2174 } 2175 p = c.call(s, e, p); 2176 switch(typeof p){ 2177 case "string": 2178 return strEscape(p); 2179 case "object": 2180 { 2181 if (p === null) { 2182 return "null"; 2183 } 2184 if (l.indexOf(p) !== -1) { 2185 return n; 2186 } 2187 let e = ""; 2188 let t = ","; 2189 const r = g; 2190 if (Array.isArray(p)) { 2191 if (p.length === 0) { 2192 return "[]"; 2193 } 2194 if (u < l.length + 1) { 2195 return '"[Array]"'; 2196 } 2197 l.push(p); 2198 if (a !== "") { 2199 g += a; 2200 e += `\n${g}`; 2201 t = `,\n${g}`; 2202 } 2203 const n = Math.min(p.length, o); 2204 let i = 0; 2205 for(; i < n - 1; i++){ 2206 const n = stringifyFnReplacer(String(i), p, l, c, a, g); 2207 e += n !== undefined ? n : "null"; 2208 e += t; 2209 } 2210 const f = stringifyFnReplacer(String(i), p, l, c, a, g); 2211 e += f !== undefined ? f : "null"; 2212 if (p.length - 1 > o) { 2213 const n = p.length - o - 1; 2214 e += `${t}"... ${getItemCount(n)} not stringified"`; 2215 } 2216 if (a !== "") { 2217 e += `\n${r}`; 2218 } 2219 l.pop(); 2220 return `[${e}]`; 2221 } 2222 let s = Object.keys(p); 2223 const y = s.length; 2224 if (y === 0) { 2225 return "{}"; 2226 } 2227 if (u < l.length + 1) { 2228 return '"[Object]"'; 2229 } 2230 let d = ""; 2231 let h = ""; 2232 if (a !== "") { 2233 g += a; 2234 t = `,\n${g}`; 2235 d = " "; 2236 } 2237 const $ = Math.min(y, o); 2238 if (i && !isTypedArrayWithEntries(p)) { 2239 s = sort(s, f); 2240 } 2241 l.push(p); 2242 for(let n = 0; n < $; n++){ 2243 const r = s[n]; 2244 const i = stringifyFnReplacer(r, p, l, c, a, g); 2245 if (i !== undefined) { 2246 e += `${h}${strEscape(r)}:${d}${i}`; 2247 h = t; 2248 } 2249 } 2250 if (y > o) { 2251 const n = y - o; 2252 e += `${h}"...":${d}"${getItemCount(n)} not stringified"`; 2253 h = t; 2254 } 2255 if (a !== "" && h.length > 1) { 2256 e = `\n${g}${e}\n${r}`; 2257 } 2258 l.pop(); 2259 return `{${e}}`; 2260 } 2261 case "number": 2262 return isFinite(p) ? String(p) : t ? t(p) : "null"; 2263 case "boolean": 2264 return p === true ? "true" : "false"; 2265 case "undefined": 2266 return undefined; 2267 case "bigint": 2268 if (r) { 2269 return String(p); 2270 } 2271 default: 2272 return t ? t(p) : undefined; 2273 } 2274 } 2275 function stringifyArrayReplacer(e, i, f, s, l, c) { 2276 if (typeof i === "object" && i !== null && typeof i.toJSON === "function") { 2277 i = i.toJSON(e); 2278 } 2279 switch(typeof i){ 2280 case "string": 2281 return strEscape(i); 2282 case "object": 2283 { 2284 if (i === null) { 2285 return "null"; 2286 } 2287 if (f.indexOf(i) !== -1) { 2288 return n; 2289 } 2290 const e = c; 2291 let t = ""; 2292 let r = ","; 2293 if (Array.isArray(i)) { 2294 if (i.length === 0) { 2295 return "[]"; 2296 } 2297 if (u < f.length + 1) { 2298 return '"[Array]"'; 2299 } 2300 f.push(i); 2301 if (l !== "") { 2302 c += l; 2303 t += `\n${c}`; 2304 r = `,\n${c}`; 2305 } 2306 const n = Math.min(i.length, o); 2307 let a = 0; 2308 for(; a < n - 1; a++){ 2309 const e = stringifyArrayReplacer(String(a), i[a], f, s, l, c); 2310 t += e !== undefined ? e : "null"; 2311 t += r; 2312 } 2313 const g = stringifyArrayReplacer(String(a), i[a], f, s, l, c); 2314 t += g !== undefined ? g : "null"; 2315 if (i.length - 1 > o) { 2316 const e = i.length - o - 1; 2317 t += `${r}"... ${getItemCount(e)} not stringified"`; 2318 } 2319 if (l !== "") { 2320 t += `\n${e}`; 2321 } 2322 f.pop(); 2323 return `[${t}]`; 2324 } 2325 f.push(i); 2326 let a = ""; 2327 if (l !== "") { 2328 c += l; 2329 r = `,\n${c}`; 2330 a = " "; 2331 } 2332 let g = ""; 2333 for (const e of s){ 2334 const n = stringifyArrayReplacer(e, i[e], f, s, l, c); 2335 if (n !== undefined) { 2336 t += `${g}${strEscape(e)}:${a}${n}`; 2337 g = r; 2338 } 2339 } 2340 if (l !== "" && g.length > 1) { 2341 t = `\n${c}${t}\n${e}`; 2342 } 2343 f.pop(); 2344 return `{${t}}`; 2345 } 2346 case "number": 2347 return isFinite(i) ? String(i) : t ? t(i) : "null"; 2348 case "boolean": 2349 return i === true ? "true" : "false"; 2350 case "undefined": 2351 return undefined; 2352 case "bigint": 2353 if (r) { 2354 return String(i); 2355 } 2356 default: 2357 return t ? t(i) : undefined; 2358 } 2359 } 2360 function stringifyIndent(e, s, l, c, a) { 2361 switch(typeof s){ 2362 case "string": 2363 return strEscape(s); 2364 case "object": 2365 { 2366 if (s === null) { 2367 return "null"; 2368 } 2369 if (typeof s.toJSON === "function") { 2370 s = s.toJSON(e); 2371 if (typeof s !== "object") { 2372 return stringifyIndent(e, s, l, c, a); 2373 } 2374 if (s === null) { 2375 return "null"; 2376 } 2377 } 2378 if (l.indexOf(s) !== -1) { 2379 return n; 2380 } 2381 const t = a; 2382 if (Array.isArray(s)) { 2383 if (s.length === 0) { 2384 return "[]"; 2385 } 2386 if (u < l.length + 1) { 2387 return '"[Array]"'; 2388 } 2389 l.push(s); 2390 a += c; 2391 let e = `\n${a}`; 2392 const n = `,\n${a}`; 2393 const r = Math.min(s.length, o); 2394 let i = 0; 2395 for(; i < r - 1; i++){ 2396 const t = stringifyIndent(String(i), s[i], l, c, a); 2397 e += t !== undefined ? t : "null"; 2398 e += n; 2399 } 2400 const f = stringifyIndent(String(i), s[i], l, c, a); 2401 e += f !== undefined ? f : "null"; 2402 if (s.length - 1 > o) { 2403 const t = s.length - o - 1; 2404 e += `${n}"... ${getItemCount(t)} not stringified"`; 2405 } 2406 e += `\n${t}`; 2407 l.pop(); 2408 return `[${e}]`; 2409 } 2410 let r = Object.keys(s); 2411 const g = r.length; 2412 if (g === 0) { 2413 return "{}"; 2414 } 2415 if (u < l.length + 1) { 2416 return '"[Object]"'; 2417 } 2418 a += c; 2419 const p = `,\n${a}`; 2420 let y = ""; 2421 let d = ""; 2422 let h = Math.min(g, o); 2423 if (isTypedArrayWithEntries(s)) { 2424 y += stringifyTypedArray(s, p, o); 2425 r = r.slice(s.length); 2426 h -= s.length; 2427 d = p; 2428 } 2429 if (i) { 2430 r = sort(r, f); 2431 } 2432 l.push(s); 2433 for(let e = 0; e < h; e++){ 2434 const t = r[e]; 2435 const n = stringifyIndent(t, s[t], l, c, a); 2436 if (n !== undefined) { 2437 y += `${d}${strEscape(t)}: ${n}`; 2438 d = p; 2439 } 2440 } 2441 if (g > o) { 2442 const e = g - o; 2443 y += `${d}"...": "${getItemCount(e)} not stringified"`; 2444 d = p; 2445 } 2446 if (d !== "") { 2447 y = `\n${a}${y}\n${t}`; 2448 } 2449 l.pop(); 2450 return `{${y}}`; 2451 } 2452 case "number": 2453 return isFinite(s) ? String(s) : t ? t(s) : "null"; 2454 case "boolean": 2455 return s === true ? "true" : "false"; 2456 case "undefined": 2457 return undefined; 2458 case "bigint": 2459 if (r) { 2460 return String(s); 2461
2461 } 2462 default: 2463 return t ? t(s) : undefined; 2464 } 2465 } 2466 function stringifySimple(e, s, l) { 2467 switch(typeof s){ 2468 case "string": 2469 return strEscape(s); 2470 case "object": 2471 { 2472 if (s === null) { 2473 return "null"; 2474 } 2475 if (typeof s.toJSON === "function") { 2476 s = s.toJSON(e); 2477 if (typeof s !== "object") { 2478 return stringifySimple(e, s, l); 2479 } 2480 if (s === null) { 2481 return "null"; 2482 } 2483 } 2484 if (l.indexOf(s) !== -1) { 2485 return n; 2486 } 2487 let t = ""; 2488 const r = s.length !== undefined; 2489 if (r && Array.isArray(s)) { 2490 if (s.length === 0) { 2491 return "[]"; 2492 } 2493 if (u < l.length + 1) { 2494 return '"[Array]"'; 2495 } 2496 l.push(s); 2497 const e = Math.min(s.length, o); 2498 let n = 0; 2499 for(; n < e - 1; n++){ 2500 const e = stringifySimple(String(n), s[n], l); 2501 t += e !== undefined ? e : "null"; 2502 t += ","; 2503 } 2504 const r = stringifySimple(String(n), s[n], l); 2505 t += r !== undefined ? r : "null"; 2506 if (s.length - 1 > o) { 2507 const e = s.length - o - 1; 2508 t += `,"... ${getItemCount(e)} not stringified"`; 2509 } 2510 l.pop(); 2511 return `[${t}]`; 2512 } 2513 let c = Object.keys(s); 2514 const a = c.length; 2515 if (a === 0) { 2516 return "{}"; 2517 } 2518 if (u < l.length + 1) { 2519 return '"[Object]"'; 2520 } 2521 let g = ""; 2522 let p = Math.min(a, o); 2523 if (r && isTypedArrayWithEntries(s)) { 2524 t += stringifyTypedArray(s, ",", o); 2525 c = c.slice(s.length); 2526 p -= s.length; 2527 g = ","; 2528 } 2529 if (i) { 2530 c = sort(c, f); 2531 } 2532 l.push(s); 2533 for(let e = 0; e < p; e++){ 2534 const n = c[e]; 2535 const r = stringifySimple(n, s[n], l); 2536 if (r !== undefined) { 2537 t += `${g}${strEscape(n)}:${r}`; 2538 g = ","; 2539 } 2540 } 2541 if (a > o) { 2542 const e = a - o; 2543 t += `${g}"...":"${getItemCount(e)} not stringified"`; 2544 } 2545 l.pop(); 2546 return `{${t}}`; 2547 } 2548 case "number": 2549 return isFinite(s) ? String(s) : t ? t(s) : "null"; 2550 case "boolean": 2551 return s === true ? "true" : "false"; 2552 case "undefined": 2553 return undefined; 2554 case "bigint": 2555 if (r) { 2556 return String(s); 2557 } 2558 default: 2559 return t ? t(s) : undefined; 2560 } 2561 } 2562 function stringify(e, t, n) { 2563 if (arguments.length > 1) { 2564 let r = "";
2565 if (typeof n === "number") { 2566 r = " ".repeat(Math.min(n, 10)); 2567 } else if (typeof n === "string") { 2568 r = n.slice(0, 10); 2569 } 2570 if (t != null) { 2571 if (typeof t === "function") { 2572 return stringifyFnReplacer("", { 2573 "": e 2574 }, [], t, r, ""); 2575 } 2576 if (Array.isArray(t)) { 2577 return stringifyArrayReplacer("", e, [], getUniqueReplacerSet(t), r, ""); 2578 } 2579 } 2580 if (r.length !== 0) { 2581 return stringifyIndent("", e, [], r, ""); 2582 } 2583 } 2584 return stringifySimple("", e, []); 2585 } 2586 return stringify; 2587 } 2588 } 2589 }; 2590 var t = {}; 2591 function __nccwpck_require__(n) { 2592 var r = t[n]; 2593 if (r !== undefined) { 2594 return r.exports; 2595 } 2596 var i = t[n] = { 2597 exports: {} 2598 }; 2599 var f = true; 2600 try { 2601 e[n](i, i.exports, __nccwpck_require__); 2602 f = false;
vendor: 4,663 bytes, lines 2603-2695
2603 } finally{ 2604 if (f) delete t[n]; 2605 } 2606 return i.exports; 2607 } 2608 if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = ("TURBOPACK compile-time value", "/ROOT/node_modules/next/dist/compiled/safe-stable-stringify") + "/"; 2609 var n = __nccwpck_require__(879); 2610 module.exports = n; 2611})(); 2612}), 2613"[project]/node_modules/next/dist/compiled/scheduler/cjs/scheduler.development.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => { 2614"use strict"; 2615 2616var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)"); 2617/** 2618 * @license React 2619 * scheduler.development.js 2620 * 2621 * Copyright (c) Meta Platforms, Inc. and affiliates. 2622 * 2623 * This source code is licensed under the MIT license found in the 2624 * LICENSE file in the root directory of this source tree. 2625 */ "use strict"; 2626"production" !== ("TURBOPACK compile-time value", "development") && function() { 2627 function performWorkUntilDeadline() { 2628 needsPaint = !1; 2629 if (isMessageLoopRunning) { 2630 var currentTime = exports.unstable_now(); 2631 startTime = currentTime; 2632 var hasMoreWork = !0; 2633 try { 2634 a: { 2635 isHostCallbackScheduled = !1; 2636 isHostTimeoutScheduled && (isHostTimeoutScheduled = !1, localClearTimeout(taskTimeoutID), taskTimeoutID = -1); 2637 isPerformingWork = !0; 2638 var previousPriorityLevel = currentPriorityLevel; 2639 try { 2640 b: { 2641 advanceTimers(currentTime); 2642 for(currentTask = peek(taskQueue); null !== currentTask && !(currentTask.expirationTime > currentTime && shouldYieldToHost());){ 2643 var callback = currentTask.callback; 2644 if ("function" === typeof callback) { 2645 currentTask.callback = null; 2646 currentPriorityLevel = currentTask.priorityLevel; 2647 var continuationCallback = callback(currentTask.expirationTime <= currentTime); 2648 currentTime = exports.unstable_now(); 2649 if ("function" === typeof continuationCallback) { 2650 currentTask.callback = continuationCallback; 2651 advanceTimers(currentTime); 2652 hasMoreWork = !0; 2653 break b; 2654 } 2655 currentTask === peek(taskQueue) && pop(taskQueue); 2656 advanceTimers(currentTime); 2657 } else pop(taskQueue); 2658 currentTask = peek(taskQueue); 2659 } 2660 if (null !== currentTask) hasMoreWork = !0; 2661 else { 2662 var firstTimer = peek(timerQueue); 2663 null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); 2664 hasMoreWork = !1; 2665 } 2666 } 2667 break a; 2668 } finally{ 2669 currentTask = null, currentPriorityLevel = previousPriorityLevel, isPerformingWork = !1; 2670 } 2671 hasMoreWork = void 0; 2672 } 2673 } finally{ 2674 hasMoreWork ? schedulePerformWorkUntilDeadline() : isMessageLoopRunning = !1; 2675 } 2676 } 2677 } 2678 function push(heap, node) { 2679 var index = heap.length; 2680 heap.push(node); 2681 a: for(; 0 < index;){ 2682 var parentIndex = index - 1 >>> 1, parent = heap[parentIndex]; 2683 if (0 < compare(parent, node)) heap[parentIndex] = node, heap[index] = parent, index = parentIndex; 2684 else break a; 2685 } 2686 } 2687 function peek(heap) { 2688 return 0 === heap.length ? null : heap[0]; 2689 } 2690 function pop(heap) { 2691 if (0 === heap.length) return null; 2692 var first = heap[0], last = heap.pop(); 2693 if (last !== first) { 2694 heap[0] = last; 2695 a: for(var index = 0, length = heap.length, halfLength = length >>> 1; index < halfLength;){
vendor: 7,986 bytes, lines 2696-2861
2696 var leftIndex = 2 * (index + 1) - 1, left = heap[leftIndex], rightIndex = leftIndex + 1, right = heap[rightIndex]; 2697 if (0 > compare(left, last)) rightIndex < length && 0 > compare(right, left) ? (heap[index] = right, heap[rightIndex] = last, index = rightIndex) : (heap[index] = left, heap[leftIndex] = last, index = leftIndex); 2698 else if (rightIndex < length && 0 > compare(right, last)) heap[index] = right, heap[rightIndex] = last, index = rightIndex; 2699 else break a; 2700 } 2701 } 2702 return first; 2703 } 2704 function compare(a, b) { 2705 var diff = a.sortIndex - b.sortIndex; 2706 return 0 !== diff ? diff : a.id - b.id; 2707 } 2708 function advanceTimers(currentTime) { 2709 for(var timer = peek(timerQueue); null !== timer;){ 2710 if (null === timer.callback) pop(timerQueue); 2711 else if (timer.startTime <= currentTime) pop(timerQueue), timer.sortIndex = timer.expirationTime, push(taskQueue, timer); 2712 else break; 2713 timer = peek(timerQueue); 2714 } 2715 } 2716 function handleTimeout(currentTime) { 2717 isHostTimeoutScheduled = !1; 2718 advanceTimers(currentTime); 2719 if (!isHostCallbackScheduled) if (null !== peek(taskQueue)) isHostCallbackScheduled = !0, isMessageLoopRunning || (isMessageLoopRunning = !0, schedulePerformWorkUntilDeadline()); 2720 else { 2721 var firstTimer = peek(timerQueue); 2722 null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); 2723 } 2724 } 2725 function shouldYieldToHost() { 2726 return needsPaint ? !0 : exports.unstable_now() - startTime < frameInterval ? !1 : !0; 2727 } 2728 function requestHostTimeout(callback, ms) { 2729 taskTimeoutID = localSetTimeout(function() { 2730 callback(exports.unstable_now()); 2731 }, ms); 2732 } 2733 "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error()); 2734 exports.unstable_now = void 0; 2735 if ("object" === typeof performance && "function" === typeof performance.now) { 2736 var localPerformance = performance; 2737 exports.unstable_now = function() { 2738 return localPerformance.now(); 2739 }; 2740 } else { 2741 var localDate = Date, initialTime = localDate.now(); 2742 exports.unstable_now = function() { 2743 return localDate.now() - initialTime; 2744 }; 2745 } 2746 var taskQueue = [], timerQueue = [], taskIdCounter = 1, currentTask = null, currentPriorityLevel = 3, isPerformingWork = !1, isHostCallbackScheduled = !1, isHostTimeoutScheduled = !1, needsPaint = !1, localSetTimeout = "function" === typeof setTimeout ? setTimeout : null, localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null, localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null, isMessageLoopRunning = !1, taskTimeoutID = -1, frameInterval = 5, startTime = -1; 2747 if ("function" === typeof localSetImmediate) var schedulePerformWorkUntilDeadline = function() { 2748 localSetImmediate(performWorkUntilDeadline); 2749 }; 2750 else if ("undefined" !== typeof MessageChannel) { 2751 var channel = new MessageChannel(), port = channel.port2; 2752 channel.port1.onmessage = performWorkUntilDeadline; 2753 schedulePerformWorkUntilDeadline = function() { 2754 port.postMessage(null); 2755 }; 2756 } else schedulePerformWorkUntilDeadline = function() { 2757 localSetTimeout(performWorkUntilDeadline, 0); 2758 }; 2759 exports.unstable_IdlePriority = 5; 2760 exports.unstable_ImmediatePriority = 1; 2761 exports.unstable_LowPriority = 4; 2762 exports.unstable_NormalPriority = 3; 2763 exports.unstable_Profiling = null; 2764 exports.unstable_UserBlockingPriority = 2; 2765 exports.unstable_cancelCallback = function(task) { 2766 task.callback = null; 2767 }; 2768 exports.unstable_forceFrameRate = function(fps) { 2769 0 > fps || 125 < fps ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5; 2770 }; 2771 exports.unstable_getCurrentPriorityLevel = function() { 2772 return currentPriorityLevel; 2773 }; 2774 exports.unstable_next = function(eventHandler) { 2775 switch(currentPriorityLevel){ 2776 case 1: 2777 case 2: 2778 case 3: 2779 var priorityLevel = 3; 2780 break; 2781 default: 2782 priorityLevel = currentPriorityLevel; 2783 } 2784 var previousPriorityLevel = currentPriorityLevel; 2785 currentPriorityLevel = priorityLevel; 2786 try { 2787 return eventHandler(); 2788 } finally{ 2789 currentPriorityLevel = previousPriorityLevel; 2790 } 2791 }; 2792 exports.unstable_requestPaint = function() { 2793 needsPaint = !0; 2794 }; 2795 exports.unstable_runWithPriority = function(priorityLevel, eventHandler) { 2796 switch(priorityLevel){ 2797 case 1: 2798 case 2: 2799 case 3: 2800 case 4: 2801 case 5: 2802 break; 2803 default: 2804 priorityLevel = 3; 2805 } 2806 var previousPriorityLevel = currentPriorityLevel; 2807 currentPriorityLevel = priorityLevel; 2808 try { 2809 return eventHandler(); 2810 } finally{ 2811 currentPriorityLevel = previousPriorityLevel; 2812 } 2813 }; 2814 exports.unstable_scheduleCallback = function(priorityLevel, callback, options) { 2815 var currentTime = exports.unstable_now(); 2816 "object" === typeof options && null !== options ? (options = options.delay, options = "number" === typeof options && 0 < options ? currentTime + options : currentTime) : options = currentTime; 2817 switch(priorityLevel){ 2818 case 1: 2819 var timeout = -1; 2820 break; 2821 case 2: 2822 timeout = 250; 2823 break; 2824 case 5: 2825 timeout = 1073741823; 2826 break; 2827 case 4: 2828 timeout = 1e4; 2829 break; 2830 default: 2831 timeout = 5e3; 2832 } 2833 timeout = options + timeout; 2834 priorityLevel = { 2835 id: taskIdCounter++, 2836 callback: callback, 2837 priorityLevel: priorityLevel, 2838 startTime: options, 2839 expirationTime: timeout, 2840 sortIndex: -1 2841 }; 2842 options > currentTime ? (priorityLevel.sortIndex = options, push(timerQueue, priorityLevel), null === peek(taskQueue) && priorityLevel === peek(timerQueue) && (isHostTimeoutScheduled ? (localClearTimeout(taskTimeoutID), taskTimeoutID = -1) : isHostTimeoutScheduled = !0, requestHostTimeout(handleTimeout, options - currentTime))) : (priorityLevel.sortIndex = timeout, push(taskQueue, priorityLevel), isHostCallbackScheduled || isPerformingWork || (isHostCallbackScheduled = !0, isMessageLoopRunning || (isMessageLoopRunning = !0, schedulePerformWorkUntilDeadline()))); 2843 return priorityLevel; 2844 }; 2845 exports.unstable_shouldYield = shouldYieldToHost; 2846 exports.unstable_wrapCallback = function(callback) { 2847 var parentPriorityLevel = currentPriorityLevel; 2848 return function() { 2849 var previousPriorityLevel = currentPriorityLevel; 2850 currentPriorityLevel = parentPriorityLevel; 2851 try { 2852 return callback.apply(this, arguments); 2853 } finally{ 2854 currentPriorityLevel = previousPriorityLevel; 2855 } 2856 }; 2857 }; 2858 "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error()); 2859}(); 2860}), 2861"[project]/node_modules/next/dist/compiled/scheduler/index.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports
2861) => { 2862"use strict"; 2863 2864var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)"); 2865'use strict'; 2866if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 2867; 2868else { 2869 module.exports = __turbopack_context__.r("[project]/node_modules/next/dist/compiled/scheduler/cjs/scheduler.development.js [app-client] (ecmascript)"); 2870} 2871}), 2872"[project]/node_modules/next/dist/compiled/strip-ansi/index.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => { 2873 2874(()=>{ 2875 "use strict"; 2876 var e = { 2877 511: (e)=>{ 2878 e.exports = ({ onlyFirst: e = false } = {})=>{ 2879 const r = [ 2880 "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", 2881 "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))" 2882 ].join("|"); 2883 return new RegExp(r, e ? undefined : "g"); 2884 }; 2885 }, 2886 532: (e, r, _)=>{ 2887 const t = _(511); 2888 e.exports = (e)=>typeof e === "string" ? e.replace(t(), "") : e; 2889 } 2890 }; 2891 var r = {}; 2892 function __nccwpck_require__(_) { 2893 var t = r[_]; 2894 if (t !== undefined) { 2895 return t.exports; 2896 } 2897 var a = r[_] = { 2898 exports: {} 2899 }; 2900 var n = true; 2901 try { 2902 e[_](a, a.exports, __nccwpck_require__); 2903 n = false; 2904 } finally{ 2905 if (n) delete r[_]; 2906 } 2907 return a.exports; 2908 } 2909 if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = ("TURBOPACK compile-time value", "/ROOT/node_modules/next/dist/compiled/strip-ansi") + "/"; 2910 var _ = __nccwpck_require__(532); 2911 module.exports = _; 2912})(); 2913}), 2914]); 2915 2916//# sourceMappingURL=node_modules_next_dist_compiled_a0e4c7b4._.js.map
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.