1import { 2 __commonJS 3} from "/node_modules/.vite/deps/chunk-BUSYA2B4.js?v=9e8fcb68"; 4
vendor: 44,941 bytes, lines 5-976
5// node_modules/react/cjs/react.development.js 6var require_react_development = __commonJS({ 7 "node_modules/react/cjs/react.development.js"(exports, module) { 8 "use strict"; 9 (function() { 10 function defineDeprecationWarning(methodName, info) { 11 Object.defineProperty(Component.prototype, methodName, { 12 get: function() { 13 console.warn( 14 "%s(...) is deprecated in plain JavaScript React classes. %s", 15 info[0], 16 info[1] 17 ); 18 } 19 }); 20 } 21 function getIteratorFn(maybeIterable) { 22 if (null === maybeIterable || "object" !== typeof maybeIterable) 23 return null; 24 maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"]; 25 return "function" === typeof maybeIterable ? maybeIterable : null; 26 } 27 function warnNoop(publicInstance, callerName) { 28 publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass"; 29 var warningKey = publicInstance + "." + callerName; 30 didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error( 31 "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.", 32 callerName, 33 publicInstance 34 ), didWarnStateUpdateForUnmountedComponent[warningKey] = true); 35 } 36 function Component(props, context, updater) { 37 this.props = props; 38 this.context = context; 39 this.refs = emptyObject; 40 this.updater = updater || ReactNoopUpdateQueue; 41 } 42 function ComponentDummy() { 43 } 44 function PureComponent(props, context, updater) { 45 this.props = props; 46 this.context = context; 47 this.refs = emptyObject; 48 this.updater = updater || ReactNoopUpdateQueue; 49 } 50 function noop() { 51 } 52 function testStringCoercion(value) { 53 return "" + value; 54 } 55 function checkKeyStringCoercion(value) { 56 try { 57 testStringCoercion(value); 58 var JSCompiler_inline_result = false; 59 } catch (e) { 60 JSCompiler_inline_result = true; 61 } 62 if (JSCompiler_inline_result) { 63 JSCompiler_inline_result = console; 64 var JSCompiler_temp_const = JSCompiler_inline_result.error; 65 var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object"; 66 JSCompiler_temp_const.call( 67 JSCompiler_inline_result, 68 "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", 69 JSCompiler_inline_result$jscomp$0 70 ); 71 return testStringCoercion(value); 72 } 73 } 74 function getComponentNameFromType(type) { 75 if (null == type) return null; 76 if ("function" === typeof type) 77 return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null; 78 if ("string" === typeof type) return type; 79 switch (type) { 80 case REACT_FRAGMENT_TYPE: 81 return "Fragment"; 82 case REACT_PROFILER_TYPE: 83 return "Profiler"; 84 case REACT_STRICT_MODE_TYPE: 85 return "StrictMode"; 86 case REACT_SUSPENSE_TYPE: 87 return "Suspense"; 88 case REACT_SUSPENSE_LIST_TYPE: 89 return "SuspenseList"; 90 case REACT_ACTIVITY_TYPE: 91 return "Activity"; 92 } 93 if ("object" === typeof type) 94 switch ("number" === typeof type.tag && console.error( 95 "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue." 96 ), type.$$typeof) { 97 case REACT_PORTAL_TYPE: 98 return "Portal"; 99 case REACT_CONTEXT_TYPE: 100 return type.displayName || "Context"; 101 case REACT_CONSUMER_TYPE: 102 return (type._context.displayName || "Context") + ".Consumer"; 103 case REACT_FORWARD_REF_TYPE: 104 var innerType = type.render; 105 type = type.displayName; 106 type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"); 107 return type; 108 case REACT_MEMO_TYPE: 109 return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo"; 110 case REACT_LAZY_TYPE: 111 innerType = type._payload; 112 type = type._init; 113 try { 114 return getComponentNameFromType(type(innerType)); 115 } catch (x) { 116 } 117 } 118 return null; 119 } 120 function getTaskName(type) { 121 if (type === REACT_FRAGMENT_TYPE) return "<>"; 122 if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) 123 return "<...>"; 124 try { 125 var name = getComponentNameFromType(type); 126 return name ? "<" + name + ">" : "<...>"; 127 } catch (x) { 128 return "<...>"; 129 } 130 } 131 function getOwner() { 132 var dispatcher = ReactSharedInternals.A; 133 return null === dispatcher ? null : dispatcher.getOwner(); 134 } 135 function UnknownOwner() { 136 return Error("react-stack-top-frame"); 137 } 138 function hasValidKey(config) { 139 if (hasOwnProperty.call(config, "key")) { 140 var getter = Object.getOwnPropertyDescriptor(config, "key").get; 141 if (getter && getter.isReactWarning) return false; 142 } 143 return void 0 !== config.key; 144 } 145 function defineKeyPropWarningGetter(props, displayName) { 146 function warnAboutAccessingKey() { 147 specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error( 148 "%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)", 149 displayName 150 )); 151 } 152 warnAboutAccessingKey.isReactWarning = true; 153 Object.defineProperty(props, "key", { 154 get: warnAboutAccessingKey, 155 configurable: true 156 }); 157 } 158 function elementRefGetterWithDeprecationWarning() { 159 var componentName = getComponentNameFromType(this.type); 160 didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error( 161 "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." 162 )); 163 componentName = this.props.ref; 164 return void 0 !== componentName ? componentName : null; 165 } 166 function ReactElement(type, key, props, owner, debugStack, debugTask) { 167 var refProp = props.ref; 168 type = { 169 $$typeof: REACT_ELEMENT_TYPE, 170 type, 171 key, 172 props, 173 _owner: owner 174 }; 175 null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", { 176 enumerable: false, 177 get: elementRefGetterWithDeprecationWarning 178 }) : Object.defineProperty(type, "ref", { enumerable: false, value: null }); 179 type._store = {}; 180 Object.defineProperty(type._store, "validated", { 181 configurable: false, 182 enumerable: false, 183 writable: true, 184 value: 0 185 }); 186 Object.defineProperty(type, "_debugInfo", { 187 configurable: false, 188 enumerable: false, 189 writable: true, 190 value: null 191 }); 192 Object.defineProperty(type, "_debugStack", { 193 configurable: false, 194 enumerable: false, 195 writable: true, 196 value: debugStack 197 }); 198 Object.defineProperty(type, "_debugTask", { 199 configurable: false, 200 enumerable: false, 201 writable: true, 202 value: debugTask 203 }); 204 Object.freeze && (Object.freeze(type.props), Object.freeze(type)); 205 return type; 206 } 207 function cloneAndReplaceKey(oldElement, newKey) { 208 newKey = ReactElement( 209 oldElement.type, 210 newKey, 211 oldElement.props, 212 oldElement._owner, 213 oldElement._debugStack, 214 oldElement._debugTask 215 ); 216 oldElement._store && (newKey._store.validated = oldElement._store.validated); 217 return newKey; 218 } 219 function validateChildKeys(node) { 220 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)); 221 } 222 function isValidElement(object) { 223 return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE; 224 } 225 function escape(key) { 226 var escaperLookup = { "=": "=0", ":": "=2" }; 227 return "$" + key.replace(/[=:]/g, function(match) { 228 return escaperLookup[match]; 229 }); 230 } 231 function getElementKey(element, index) { 232 return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36); 233 } 234 function resolveThenable(thenable) { 235 switch (thenable.status) { 236 case "fulfilled": 237 return thenable.value; 238 case "rejected": 239 throw thenable.reason; 240 default: 241 switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then( 242 function(fulfilledValue) { 243 "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue); 244 }, 245 function(error) { 246 "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error); 247 } 248 )), thenable.status) { 249 case "fulfilled": 250 return thenable.value; 251 case "rejected": 252 throw thenable.reason; 253 } 254 } 255 throw thenable; 256 } 257 function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) { 258 var type = typeof children; 259 if ("undefined" === type || "boolean" === type) children = null; 260 var invokeCallback = false; 261 if (null === children) invokeCallback = true; 262 else 263 switch (type) { 264 case "bigint": 265 case "string": 266 case "number": 267 invokeCallback = true; 268 break; 269 case "object": 270 switch (children.$$typeof) { 271 case REACT_ELEMENT_TYPE: 272 case REACT_PORTAL_TYPE: 273 invokeCallback = true; 274 break; 275 case REACT_LAZY_TYPE: 276 return invokeCallback = children._init, mapIntoArray( 277 invokeCallback(children._payload), 278 array, 279 escapedPrefix, 280 nameSoFar, 281 callback 282 ); 283 } 284 } 285 if (invokeCallback) { 286 invokeCallback = children; 287 callback = callback(invokeCallback); 288 var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar; 289 isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) { 290 return c; 291 })) : null != callback && (isValidElement(callback) && (null != callback.key && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey( 292 callback, 293 escapedPrefix + (null == callback.key || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace( 294 userProvidedKeyEscapeRegex, 295 "$&/" 296 ) + "/") + childKey 297 ), "" !== nameSoFar && null != invokeCallback && isValidElement(invokeCallback) && null == invokeCallback.key && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback)); 298 return 1; 299 } 300 invokeCallback = 0; 301 childKey = "" === nameSoFar ? "." : nameSoFar + ":"; 302 if (isArrayImpl(children)) 303 for (var i = 0; i < children.length; i++) 304 nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray( 305 nameSoFar, 306 array, 307 escapedPrefix, 308 type, 309 callback 310 ); 311 else if (i = getIteratorFn(children), "function" === typeof i) 312 for (i === children.entries && (didWarnAboutMaps || console.warn( 313 "Using Maps as children is not supported. Use an array of keyed ReactElements instead." 314 ), didWarnAboutMaps = true), children = i.call(children), i = 0; !(nameSoFar = children.next()).done; ) 315 nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray( 316 nameSoFar, 317 array, 318 escapedPrefix, 319 type, 320 callback 321 ); 322 else if ("object" === type) { 323 if ("function" === typeof children.then) 324 return mapIntoArray( 325 resolveThenable(children), 326 array, 327 escapedPrefix, 328 nameSoFar, 329 callback 330 ); 331 array = String(children); 332 throw Error( 333 "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." 334 ); 335 } 336 return invokeCallback; 337 } 338 function mapChildren(children, func, context) { 339 if (null == children) return children; 340 var result = [], count = 0; 341 mapIntoArray(children, result, "", "", function(child) { 342 return func.call(context, child, count++); 343 }); 344 return result; 345 } 346 function lazyInitializer(payload) { 347 if (-1 === payload._status) { 348 var ioInfo = payload._ioInfo; 349 null != ioInfo && (ioInfo.start = ioInfo.end = performance.now()); 350 ioInfo = payload._result; 351 var thenable = ioInfo(); 352 thenable.then( 353 function(moduleObject) { 354 if (0 === payload._status || -1 === payload._status) { 355 payload._status = 1; 356 payload._result = moduleObject; 357 var _ioInfo = payload._ioInfo; 358 null != _ioInfo && (_ioInfo.end = performance.now()); 359 void 0 === thenable.status && (thenable.status = "fulfilled", thenable.value = moduleObject); 360 } 361 }, 362 function(error) { 363 if (0 === payload._status || -1 === payload._status) { 364 payload._status = 2; 365 payload._result = error; 366 var _ioInfo2 = payload._ioInfo; 367 null != _ioInfo2 && (_ioInfo2.end = performance.now()); 368 void 0 === thenable.status && (thenable.status = "rejected", thenable.reason = error); 369 } 370 } 371 ); 372 ioInfo = payload._ioInfo; 373 if (null != ioInfo) { 374 ioInfo.value = thenable; 375 var displayName = thenable.displayName; 376 "string" === typeof displayName && (ioInfo.name = displayName); 377 } 378 -1 === payload._status && (payload._status = 0, payload._result = thenable); 379 } 380 if (1 === payload._status) 381 return ioInfo = payload._result, void 0 === ioInfo && console.error( 382 "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?", 383 ioInfo 384 ), "default" in ioInfo || console.error( 385 "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))", 386 ioInfo 387 ), ioInfo.default; 388 throw payload._result; 389 } 390 function resolveDispatcher() { 391 var dispatcher = ReactSharedInternals.H; 392 null === dispatcher && console.error( 393 "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." 394 ); 395 return dispatcher; 396 } 397 function releaseAsyncTransition() { 398 ReactSharedInternals.asyncTransitions--; 399 } 400 function enqueueTask(task) { 401 if (null === enqueueTaskImpl) 402 try { 403 var requireString = ("require" + Math.random()).slice(0, 7); 404 enqueueTaskImpl = (module && module[requireString]).call( 405 module, 406 "timers" 407 ).setImmediate; 408 } catch (_err) { 409 enqueueTaskImpl = function(callback) { 410 false === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = true, "undefined" === typeof MessageChannel && console.error( 411 "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." 412 )); 413 var channel = new MessageChannel(); 414 channel.port1.onmessage = callback; 415 channel.port2.postMessage(void 0); 416 }; 417 } 418 return enqueueTaskImpl(task); 419 } 420 function aggregateErrors(errors) { 421 return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0]; 422 } 423 function popActScope(prevActQueue, prevActScopeDepth) { 424 prevActScopeDepth !== actScopeDepth - 1 && console.error( 425 "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. " 426 ); 427 actScopeDepth = prevActScopeDepth; 428 } 429 function recursivelyFlushAsyncActWork(returnValue, resolve, reject) { 430 var queue = ReactSharedInternals.actQueue; 431 if (null !== queue) 432 if (0 !== queue.length) 433 try { 434 flushActQueue(queue); 435 enqueueTask(function() { 436 return recursivelyFlushAsyncActWork(returnValue, resolve, reject); 437 }); 438 return; 439 } catch (error) { 440 ReactSharedInternals.thrownErrors.push(error); 441 } 442 else ReactSharedInternals.actQueue = null; 443 0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue); 444 } 445 function flushActQueue(queue) { 446 if (!isFlushing) { 447 isFlushing = true; 448 var i = 0; 449 try { 450 for (; i < queue.length; i++) { 451 var callback = queue[i]; 452 do { 453 ReactSharedInternals.didUsePromise = false; 454 var continuation = callback(false); 455 if (null !== continuation) { 456 if (ReactSharedInternals.didUsePromise) { 457 queue[i] = callback; 458 queue.splice(0, i); 459 return; 460 } 461 callback = continuation; 462 } else break; 463 } while (1); 464 } 465 queue.length = 0; 466 } catch (error) { 467 queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error); 468 } finally { 469 isFlushing = false; 470 } 471 } 472 } 473 "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error()); 474 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"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = { 475 isMounted: function() { 476 return false; 477 }, 478 enqueueForceUpdate: function(publicInstance) { 479 warnNoop(publicInstance, "forceUpdate"); 480 }, 481 enqueueReplaceState: function(publicInstance) { 482 warnNoop(publicInstance, "replaceState"); 483 }, 484 enqueueSetState: function(publicInstance) { 485 warnNoop(publicInstance, "setState"); 486 } 487 }, assign = Object.assign, emptyObject = {}; 488 Object.freeze(emptyObject); 489 Component.prototype.isReactComponent = {}; 490 Component.prototype.setState = function(partialState, callback) { 491 if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState) 492 throw Error( 493 "takes an object of state variables to update or a function which returns an object of state variables." 494 ); 495 this.updater.enqueueSetState(this, partialState, callback, "setState"); 496 }; 497 Component.prototype.forceUpdate = function(callback) { 498 this.updater.enqueueForceUpdate(this, callback, "forceUpdate"); 499 }; 500 var deprecatedAPIs = { 501 isMounted: [ 502 "isMounted", 503 "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks." 504 ], 505 replaceState: [ 506 "replaceState", 507 "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)." 508 ] 509 }; 510 for (fnName in deprecatedAPIs) 511 deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); 512 ComponentDummy.prototype = Component.prototype; 513 deprecatedAPIs = PureComponent.prototype = new ComponentDummy(); 514 deprecatedAPIs.constructor = PureComponent; 515 assign(deprecatedAPIs, Component.prototype); 516 deprecatedAPIs.isPureReactComponent = true; 517 var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = { 518 H: null, 519 A: null, 520 T: null, 521 S: null, 522 actQueue: null, 523 asyncTransitions: 0, 524 isBatchingLegacy: false, 525 didScheduleLegacyUpdate: false, 526 didUsePromise: false, 527 thrownErrors: [], 528 getCurrentStack: null, 529 recentlyCreatedOwnerStacks: 0 530 }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() { 531 return null; 532 }; 533 deprecatedAPIs = { 534 react_stack_bottom_frame: function(callStackForError) { 535 return callStackForError(); 536 } 537 }; 538 var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime; 539 var didWarnAboutElementRef = {}; 540 var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind( 541 deprecatedAPIs, 542 UnknownOwner 543 )(); 544 var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner)); 545 var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = "function" === typeof reportError ? reportError : function(error) { 546 if ("object" === typeof window && "function" === typeof window.ErrorEvent) { 547 var event = new window.ErrorEvent("error", { 548 bubbles: true, 549 cancelable: true, 550 message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error), 551 error 552 }); 553 if (!window.dispatchEvent(event)) return; 554 } else if ("object" === typeof process && "function" === typeof process.emit) { 555 process.emit("uncaughtException", error); 556 return; 557 } 558 console.error(error); 559 }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function(callback) { 560 queueMicrotask(function() { 561 return queueMicrotask(callback); 562 }); 563 } : enqueueTask; 564 deprecatedAPIs = Object.freeze({ 565 __proto__: null, 566 c: function(size) { 567 return resolveDispatcher().useMemoCache(size); 568 } 569 }); 570 var fnName = { 571 map: mapChildren, 572 forEach: function(children, forEachFunc, forEachContext) { 573 mapChildren( 574 children, 575 function() { 576 forEachFunc.apply(this, arguments); 577 }, 578 forEachContext 579 ); 580 }, 581 count: function(children) { 582 var n = 0; 583 mapChildren(children, function() { 584 n++; 585 }); 586 return n; 587 }, 588 toArray: function(children) { 589 return mapChildren(children, function(child) { 590 return child; 591 }) || []; 592 }, 593 only: function(children) { 594 if (!isValidElement(children)) 595 throw Error( 596 "React.Children.only expected to receive a single React element child." 597 ); 598 return children; 599 } 600 }; 601 exports.Activity = REACT_ACTIVITY_TYPE; 602 exports.Children = fnName; 603 exports.Component = Component; 604 exports.Fragment = REACT_FRAGMENT_TYPE; 605 exports.Profiler = REACT_PROFILER_TYPE; 606 exports.PureComponent = PureComponent; 607 exports.StrictMode = REACT_STRICT_MODE_TYPE; 608 exports.Suspense = REACT_SUSPENSE_TYPE; 609 exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals; 610 exports.__COMPILER_RUNTIME = deprecatedAPIs; 611 exports.act = function(callback) { 612 var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth; 613 actScopeDepth++; 614 var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = false; 615 try { 616 var result = callback(); 617 } catch (error) { 618 ReactSharedInternals.thrownErrors.push(error); 619 } 620 if (0 < ReactSharedInternals.thrownErrors.length) 621 throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback; 622 if (null !== result && "object" === typeof result && "function" === typeof result.then) { 623 var thenable = result; 624 queueSeveralMicrotasks(function() { 625 didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error( 626 "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 () => ...);" 627 )); 628 }); 629 return { 630 then: function(resolve, reject) { 631 didAwaitActCall = true; 632 thenable.then( 633 function(returnValue) { 634 popActScope(prevActQueue, prevActScopeDepth); 635 if (0 === prevActScopeDepth) { 636 try { 637 flushActQueue(queue), enqueueTask(function() { 638 return recursivelyFlushAsyncActWork( 639 returnValue, 640 resolve, 641 reject 642 ); 643 }); 644 } catch (error$0) { 645 ReactSharedInternals.thrownErrors.push(error$0); 646 } 647 if (0 < ReactSharedInternals.thrownErrors.length) { 648 var _thrownError = aggregateErrors( 649 ReactSharedInternals.thrownErrors 650 ); 651 ReactSharedInternals.thrownErrors.length = 0; 652 reject(_thrownError); 653 } 654 } else resolve(returnValue); 655 }, 656 function(error) { 657 popActScope(prevActQueue, prevActScopeDepth); 658 0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors( 659 ReactSharedInternals.thrownErrors 660 ), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error); 661 } 662 ); 663 } 664 }; 665 } 666 var returnValue$jscomp$0 = result; 667 popActScope(prevActQueue, prevActScopeDepth); 668 0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function() { 669 didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error( 670 "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)" 671 )); 672 }), ReactSharedInternals.actQueue = null); 673 if (0 < ReactSharedInternals.thrownErrors.length) 674 throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback; 675 return { 676 then: function(resolve, reject) { 677 didAwaitActCall = true; 678 0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() { 679 return recursivelyFlushAsyncActWork( 680 returnValue$jscomp$0, 681 resolve, 682 reject 683 ); 684 })) : resolve(returnValue$jscomp$0); 685 } 686 }; 687 }; 688 exports.cache = function(fn) { 689 return function() { 690 return fn.apply(null, arguments); 691 }; 692 }; 693 exports.cacheSignal = function() { 694 return null; 695 }; 696 exports.captureOwnerStack = function() { 697 var getCurrentStack = ReactSharedInternals.getCurrentStack; 698 return null === getCurrentStack ? null : getCurrentStack(); 699 }; 700 exports.cloneElement = function(element, config, children) { 701 if (null === element || void 0 === element) 702 throw Error( 703 "The argument must be a React element, but you passed " + element + "." 704 ); 705 var props = assign({}, element.props), key = element.key, owner = element._owner; 706 if (null != config) { 707 var JSCompiler_inline_result; 708 a: { 709 if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor( 710 config, 711 "ref" 712 ).get) && JSCompiler_inline_result.isReactWarning) { 713 JSCompiler_inline_result = false; 714 break a; 715 } 716 JSCompiler_inline_result = void 0 !== config.ref; 717 } 718 JSCompiler_inline_result && (owner = getOwner()); 719 hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key); 720 for (propName in config) 721 !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]); 722 } 723 var propName = arguments.length - 2; 724 if (1 === propName) props.children = children; 725 else if (1 < propName) { 726 JSCompiler_inline_result = Array(propName); 727 for (var i = 0; i < propName; i++) 728 JSCompiler_inline_result[i] = arguments[i + 2]; 729 props.children = JSCompiler_inline_result; 730 } 731 props = ReactElement( 732 element.type, 733 key, 734 props, 735 owner, 736 element._debugStack, 737 element._debugTask 738 ); 739 for (key = 2; key < arguments.length; key++) 740 validateChildKeys(arguments[key]); 741 return props; 742 }; 743 exports.createContext = function(defaultValue) { 744 defaultValue = { 745 $$typeof: REACT_CONTEXT_TYPE, 746 _currentValue: defaultValue, 747 _currentValue2: defaultValue, 748 _threadCount: 0, 749 Provider: null, 750 Consumer: null 751 }; 752 defaultValue.Provider = defaultValue; 753 defaultValue.Consumer = { 754 $$typeof: REACT_CONSUMER_TYPE, 755 _context: defaultValue 756 }; 757 defaultValue._currentRenderer = null; 758 defaultValue._currentRenderer2 = null; 759 return defaultValue; 760 }; 761 exports.createElement = function(type, config, children) { 762 for (var i = 2; i < arguments.length; i++) 763 validateChildKeys(arguments[i]); 764 i = {}; 765 var key = null; 766 if (null != config) 767 for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = true, console.warn( 768 "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" 769 )), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config) 770 hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (i[propName] = config[propName]); 771 var childrenLength = arguments.length - 2; 772 if (1 === childrenLength) i.children = children; 773 else if (1 < childrenLength) { 774 for (var childArray = Array(childrenLength), _i = 0; _i < childrenLength; _i++) 775 childArray[_i] = arguments[_i + 2]; 776 Object.freeze && Object.freeze(childArray); 777 i.children = childArray; 778 } 779 if (type && type.defaultProps) 780 for (propName in childrenLength = type.defaultProps, childrenLength) 781 void 0 === i[propName] && (i[propName] = childrenLength[propName]); 782 key && defineKeyPropWarningGetter( 783 i, 784 "function" === typeof type ? type.displayName || type.name || "Unknown" : type 785 ); 786 var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++; 787 return ReactElement( 788 type, 789 key, 790 i, 791 getOwner(), 792 propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack, 793 propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask 794 ); 795 }; 796 exports.createRef = function() { 797 var refObject = { current: null }; 798 Object.seal(refObject); 799 return refObject; 800 }; 801 exports.forwardRef = function(render) { 802 null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error( 803 "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))." 804 ) : "function" !== typeof render ? console.error( 805 "forwardRef requires a render function but was given %s.", 806 null === render ? "null" : typeof render 807 ) : 0 !== render.length && 2 !== render.length && console.error( 808 "forwardRef render functions accept exactly two parameters: props and ref. %s", 809 1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined." 810 ); 811 null != render && null != render.defaultProps && console.error( 812 "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?" 813 ); 814 var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName; 815 Object.defineProperty(elementType, "displayName", { 816 enumerable: false, 817 configurable: true, 818 get: function() { 819 return ownName; 820 }, 821 set: function(name) { 822 ownName = name; 823 render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name); 824 } 825 }); 826 return elementType; 827 }; 828 exports.isValidElement = isValidElement; 829 exports.lazy = function(ctor) { 830 ctor = { _status: -1, _result: ctor }; 831 var lazyType = { 832 $$typeof: REACT_LAZY_TYPE, 833 _payload: ctor, 834 _init: lazyInitializer 835 }, ioInfo = { 836 name: "lazy", 837 start: -1, 838 end: -1, 839 value: null, 840 owner: null, 841 debugStack: Error("react-stack-top-frame"), 842 debugTask: console.createTask ? console.createTask("lazy()") : null 843 }; 844 ctor._ioInfo = ioInfo; 845 lazyType._debugInfo = [{ awaited: ioInfo }]; 846 return lazyType; 847 }; 848 exports.memo = function(type, compare) { 849 null == type && console.error( 850 "memo: The first argument must be a component. Instead received: %s", 851 null === type ? "null" : typeof type 852 ); 853 compare = { 854 $$typeof: REACT_MEMO_TYPE, 855 type, 856 compare: void 0 === compare ? null : compare 857 }; 858 var ownName; 859 Object.defineProperty(compare, "displayName", { 860 enumerable: false, 861 configurable: true, 862 get: function() { 863 return ownName; 864 }, 865 set: function(name) { 866 ownName = name; 867 type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name); 868 } 869 }); 870 return compare; 871 }; 872 exports.startTransition = function(scope) { 873 var prevTransition = ReactSharedInternals.T, currentTransition = {}; 874 currentTransition._updatedFibers = /* @__PURE__ */ new Set(); 875 ReactSharedInternals.T = currentTransition; 876 try { 877 var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S; 878 null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue); 879 "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError)); 880 } catch (error) { 881 reportGlobalError(error); 882 } finally { 883 null === prevTransition && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn( 884 "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." 885 )), null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error( 886 "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." 887 ), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition; 888 } 889 }; 890 exports.unstable_useCacheRefresh = function() { 891 return resolveDispatcher().useCacheRefresh(); 892 }; 893 exports.use = function(usable) { 894 return resolveDispatcher().use(usable); 895 }; 896 exports.useActionState = function(action, initialState, permalink) { 897 return resolveDispatcher().useActionState( 898 action, 899 initialState, 900 permalink 901 ); 902 }; 903 exports.useCallback = function(callback, deps) { 904 return resolveDispatcher().useCallback(callback, deps); 905 }; 906 exports.useContext = function(Context) { 907 var dispatcher = resolveDispatcher(); 908 Context.$$typeof === REACT_CONSUMER_TYPE && console.error( 909 "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?" 910 ); 911 return dispatcher.useContext(Context); 912 }; 913 exports.useDebugValue = function(value, formatterFn) { 914 return resolveDispatcher().useDebugValue(value, formatterFn); 915 }; 916 exports.useDeferredValue = function(value, initialValue) { 917 return resolveDispatcher().useDeferredValue(value, initialValue); 918 }; 919 exports.useEffect = function(create, deps) { 920 null == create && console.warn( 921 "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?" 922 ); 923 return resolveDispatcher().useEffect(create, deps); 924 }; 925 exports.useEffectEvent = function(callback) { 926 return resolveDispatcher().useEffectEvent(callback); 927 }; 928 exports.useId = function() { 929 return resolveDispatcher().useId(); 930 }; 931 exports.useImperativeHandle = function(ref, create, deps) { 932 return resolveDispatcher().useImperativeHandle(ref, create, deps); 933 }; 934 exports.useInsertionEffect = function(create, deps) { 935 null == create && console.warn( 936 "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?" 937 ); 938 return resolveDispatcher().useInsertionEffect(create, deps); 939 }; 940 exports.useLayoutEffect = function(create, deps) { 941 null == create && console.warn( 942 "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?" 943 ); 944 return resolveDispatcher().useLayoutEffect(create, deps); 945 }; 946 exports.useMemo = function(create, deps) { 947 return resolveDispatcher().useMemo(create, deps); 948 }; 949 exports.useOptimistic = function(passthrough, reducer) { 950 return resolveDispatcher().useOptimistic(passthrough, reducer); 951 }; 952 exports.useReducer = function(reducer, initialArg, init) { 953 return resolveDispatcher().useReducer(reducer, initialArg, init); 954 }; 955 exports.useRef = function(initialValue) { 956 return resolveDispatcher().useRef(initialValue); 957 }; 958 exports.useState = function(initialState) { 959 return resolveDispatcher().useState(initialState); 960 }; 961 exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) { 962 return resolveDispatcher().useSyncExternalStore( 963 subscribe, 964 getSnapshot, 965 getServerSnapshot 966 ); 967 }; 968 exports.useTransition = function() { 969 return resolveDispatcher().useTransition(); 970 }; 971 exports.version = "19.2.3"; 972 "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error()); 973 })(); 974 } 975}); 976
vendor: 635 bytes, lines 977-1004
977// node_modules/react/index.js 978var require_react = __commonJS({ 979 "node_modules/react/index.js"(exports, module) { 980 if (false) { 981 module.exports = null; 982 } else { 983 module.exports = require_react_development(); 984 } 985 } 986}); 987 988export { 989 require_react 990}; 991/*! Bundled license information: 992 993react/cjs/react.development.js: 994 (** 995 * @license React 996 * react.development.js 997 * 998 * Copyright (c) Meta Platforms, Inc. and affiliates. 999 * 1000 * This source code is licensed under the MIT license found in the 1001 * LICENSE file in the root directory of this source tree. 1002 *) 1003*/ 1004//# sourceMappingURL=chunk-GZIFXP3G.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.