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