vendor: 4,673 bytes, lines 1-94
1import { t as __commonJSMin } from "/node_modules/.vite/deps/chunk-olfrzTEO.js?v=46d206a1"; 2//#region node_modules/react/cjs/react.development.js 3/** 4* @license React 5* react.development.js 6* 7* Copyright (c) Meta Platforms, Inc. and affiliates. 8* 9* This source code is licensed under the MIT license found in the 10* LICENSE file in the root directory of this source tree. 11*/ 12var require_react_development = /* @__PURE__ */ __commonJSMin(((exports, module) => { 13 (function() { 14 function defineDeprecationWarning(methodName, info) { 15 Object.defineProperty(Component.prototype, methodName, { get: function() { 16 console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]); 17 } }); 18 } 19 function getIteratorFn(maybeIterable) { 20 if (null === maybeIterable || "object" !== typeof maybeIterable) return null; 21 maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"]; 22 return "function" === typeof maybeIterable ? maybeIterable : null; 23 } 24 function warnNoop(publicInstance, callerName) { 25 publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass"; 26 var warningKey = publicInstance + "." + callerName; 27 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); 28 } 29 function Component(props, context, updater) { 30 this.props = props; 31 this.context = context; 32 this.refs = emptyObject; 33 this.updater = updater || ReactNoopUpdateQueue; 34 } 35 function ComponentDummy() {} 36 function PureComponent(props, context, updater) { 37 this.props = props; 38 this.context = context; 39 this.refs = emptyObject; 40 this.updater = updater || ReactNoopUpdateQueue; 41 } 42 function noop() {} 43 function testStringCoercion(value) { 44 return "" + value; 45 } 46 function checkKeyStringCoercion(value) { 47 try { 48 testStringCoercion(value); 49 var JSCompiler_inline_result = !1; 50 } catch (e) { 51 JSCompiler_inline_result = !0; 52 } 53 if (JSCompiler_inline_result) { 54 JSCompiler_inline_result = console; 55 var JSCompiler_temp_const = JSCompiler_inline_result.error; 56 var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object"; 57 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); 58 return testStringCoercion(value); 59 } 60 } 61 function getComponentNameFromType(type) { 62 if (null == type) return null; 63 if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null; 64 if ("string" === typeof type) return type; 65 switch (type) { 66 case REACT_FRAGMENT_TYPE: return "Fragment"; 67 case REACT_PROFILER_TYPE: return "Profiler"; 68 case REACT_STRICT_MODE_TYPE: return "StrictMode"; 69 case REACT_SUSPENSE_TYPE: return "Suspense"; 70 case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList"; 71 case REACT_ACTIVITY_TYPE: return "Activity"; 72 } 73 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) { 74 case REACT_PORTAL_TYPE: return "Portal"; 75 case REACT_CONTEXT_TYPE: return type.displayName || "Context"; 76 case REACT_CONSUMER_TYPE: return (type._context.displayName || "Context") + ".Consumer"; 77 case REACT_FORWARD_REF_TYPE: 78 var innerType = type.render; 79 type = type.displayName; 80 type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"); 81 return type; 82 case REACT_MEMO_TYPE: return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo"; 83 case REACT_LAZY_TYPE: 84 innerType = type._payload; 85 type = type._init; 86 try { 87 return getComponentNameFromType(type(innerType)); 88 } catch (x) {} 89 } 90 return null; 91 } 92 function getTaskName(type) { 93 if (type === REACT_FRAGMENT_TYPE) return "<>"; 94 if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE
94) return "<...>"; 95 try { 96 var name = getComponentNameFromType(type); 97 return name ? "<" + name + ">" : "<...>"; 98 } catch (x) { 99 return "<...>"; 100 } 101 } 102 function getOwner() { 103 var dispatcher = ReactSharedInternals.A; 104 return null === dispatcher ? null : dispatcher.getOwner(); 105 } 106 function UnknownOwner() { 107 return Error("react-stack-top-frame"); 108 } 109 function hasValidKey(config) { 110 if (hasOwnProperty.call(config, "key")) { 111 var getter = Object.getOwnPropertyDescriptor(config, "key").get; 112 if (getter && getter.isReactWarning) return !1; 113 } 114 return void 0 !== config.key; 115 } 116 function defineKeyPropWarningGetter(props, displayName) { 117 function warnAboutAccessingKey() { 118 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)); 119 } 120 warnAboutAccessingKey.isReactWarning = !0; 121 Object.defineProperty(props, "key", { 122 get: warnAboutAccessingKey, 123 configurable: !0 124 }); 125 } 126 function elementRefGetterWithDeprecationWarning() { 127 var componentName = getComponentNameFromType(this.type); 128 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.")); 129 componentName = this.props.ref; 130 return void 0 !== componentName ? componentName : null; 131 } 132 function ReactElement(type, key, props, owner, debugStack, debugTask) { 133 var refProp = props.ref; 134 type = { 135 $$typeof: REACT_ELEMENT_TYPE, 136 type, 137 key, 138 props, 139 _owner: owner 140 }; 141 null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", { 142 enumerable: !1, 143 get: elementRefGetterWithDeprecationWarning 144 }) : Object.defineProperty(type, "ref", { 145 enumerable: !1, 146 value: null 147 }); 148 type._store = {}; 149 Object.defineProperty(type._store, "validated", { 150 configurable: !1, 151 enumerable: !1, 152 writable: !0, 153 value: 0 154 }); 155 Object.defineProperty(type, "_debugInfo", { 156 configurable: !1, 157 enumerable: !1, 158 writable: !0, 159 value: null 160 }); 161 Object.defineProperty(type, "_debugStack", { 162 configurable: !1, 163 enumerable: !1, 164 writable: !0, 165 value: debugStack 166 }); 167 Object.defineProperty(type, "_debugTask", { 168 configurable: !1, 169 enumerable: !1, 170 writable: !0, 171 value: debugTask 172 }); 173 Object.freeze && (Object.freeze(type.props), Object.freeze(type)); 174 return type; 175 } 176 function cloneAndReplaceKey(oldElement, newKey) { 177 newKey = ReactElement(oldElement.type, newKey, oldElement.props, oldElement._owner, oldElement._debugStack, oldElement._debugTask); 178 oldElement._store && (newKey._store.validated = oldElement._store.validated); 179 return newKey; 180 } 181 function validateChildKeys(node) { 182 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)); 183 } 184 function isValidElement(object) { 185 return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE; 186 } 187 function escape(key) { 188 var escaperLookup = { 189 "=": "=0", 190 ":": "=2" 191 }; 192 return "$" + key.replace(/[=:]/g, function(match) { 193 return escaperLookup[match]; 194 }); 195 } 196 function getElementKey(element, index) { 197 return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36); 198 } 199 function resolveThenable(thenable) { 200 switch (thenable.status) { 201 case "fulfilled": return thenable.value; 202 case "rejected": throw thenable.reason; 203 default: switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(function(fulfilledValue) { 204 "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue); 205 }, function(error) { 206 "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error); 207 })), thenable.status) { 208 case "fulfilled": return thenable.value; 209 case "rejected": throw thenable.reason; 210 } 211 } 212 throw thenable; 213 } 214 function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) { 215 var type = typeof children; 216 if ("undefined" === type || "boolean" === type) children = null; 217 var invokeCallback = !1; 218 if (null === children) invokeCallback = !0; 219 else switch (type) { 220 case "bigint": 221 case "string": 222 case "number": 223 invokeCallback = !0; 224 break; 225 case "object": switch (children.$$typeof) { 226 case REACT_ELEMENT_TYPE: 227 case REACT_PORTAL_TYPE: 228 invokeCallback = !0; 229 break; 230 case REACT_LAZY_TYPE: return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback); 231 } 232 } 233 if (invokeCallback) { 234 invokeCallback = children; 235 callback = callback(invokeCallback); 236 var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar; 237 isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) { 238 return c; 239 })) : 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)); 240 return 1; 241 } 242 invokeCallback = 0; 243 childKey = "" === nameSoFar ? "." : nameSoFar + ":"; 244 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); 245 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); 246 else if ("object" === type) { 247 if ("function" === typeof children.then) return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback); 248 array = String(children); 249 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."); 250 } 251 return invokeCallback; 252 } 253 function mapChildren(children, func, context) { 254 if (null == children) return children; 255 var result = [], count = 0; 256 mapIntoArray(children, result, "", "", function(child) { 257 return func.call(context, child, count++); 258 }); 259 return result; 260 } 261 function lazyInitializer(payload) { 262 if (-1 === payload._status) { 263 var ioInfo = payload._ioInfo; 264 null != ioInfo && (ioInfo.start = ioInfo.end = performance.now()); 265 ioInfo = payload._result; 266 var thenable = ioInfo(); 267 thenable.then(function(moduleObject) { 268 if (0 === payload._status || -1 === payload._status) { 269 payload._status = 1; 270 payload._result = moduleObject; 271 var _ioInfo = payload._ioInfo; 272 null != _ioInfo && (_ioInfo.end = performance.now()); 273 void 0 === thenable.status && (thenable.status = "fulfilled", thenable.value = moduleObject); 274 } 275 }, function(error) { 276 if (0 === payload._status || -1 === payload._status) { 277 payload._status = 2; 278 payload._result = error; 279 var _ioInfo2 = payload._ioInfo; 280 null != _ioInfo2 && (_ioInfo2.end = performance.now()); 281 void 0 === thenable.status && (thenable.status = "rejected", thenable.reason = error); 282 } 283 }); 284 ioInfo = payload._ioInfo; 285 if (null != ioInfo) { 286 ioInfo.value = thenable; 287 var displayName = thenable.displayName; 288 "string" === typeof displayName && (ioInfo.name = displayName); 289 } 290 -1 === payload._status && (payload._status = 0, payload._result = thenable); 291 } 292 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; 293 throw payload._result; 294 } 295 function resolveDispatcher() { 296 var dispatcher = ReactSharedInternals.H; 297 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.");
vendor: 4,863 bytes, lines 298-391
298 return dispatcher; 299 } 300 function releaseAsyncTransition() { 301 ReactSharedInternals.asyncTransitions--; 302 } 303 function enqueueTask(task) { 304 if (null === enqueueTaskImpl) try { 305 var requireString = ("require" + Math.random()).slice(0, 7); 306 enqueueTaskImpl = (module && module[requireString]).call(module, "timers").setImmediate; 307 } catch (_err) { 308 enqueueTaskImpl = function(callback) { 309 !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.")); 310 var channel = new MessageChannel(); 311 channel.port1.onmessage = callback; 312 channel.port2.postMessage(void 0); 313 }; 314 } 315 return enqueueTaskImpl(task); 316 } 317 function aggregateErrors(errors) { 318 return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0]; 319 } 320 function popActScope(prevActQueue, prevActScopeDepth) { 321 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. "); 322 actScopeDepth = prevActScopeDepth; 323 } 324 function recursivelyFlushAsyncActWork(returnValue, resolve, reject) { 325 var queue = ReactSharedInternals.actQueue; 326 if (null !== queue) if (0 !== queue.length) try { 327 flushActQueue(queue); 328 enqueueTask(function() { 329 return recursivelyFlushAsyncActWork(returnValue, resolve, reject); 330 }); 331 return; 332 } catch (error) { 333 ReactSharedInternals.thrownErrors.push(error); 334 } 335 else ReactSharedInternals.actQueue = null; 336 0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue); 337 } 338 function flushActQueue(queue) { 339 if (!isFlushing) { 340 isFlushing = !0; 341 var i = 0; 342 try { 343 for (; i < queue.length; i++) { 344 var callback = queue[i]; 345 do { 346 ReactSharedInternals.didUsePromise = !1; 347 var continuation = callback(!1); 348 if (null !== continuation) { 349 if (ReactSharedInternals.didUsePromise) { 350 queue[i] = callback; 351 queue.splice(0, i); 352 return; 353 } 354 callback = continuation; 355 } else break; 356 } while (1); 357 } 358 queue.length = 0; 359 } catch (error) { 360 queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error); 361 } finally { 362 isFlushing = !1; 363 } 364 } 365 } 366 "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error()); 367 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 = { 368 isMounted: function() { 369 return !1; 370 }, 371 enqueueForceUpdate: function(publicInstance) { 372 warnNoop(publicInstance, "forceUpdate"); 373 }, 374 enqueueReplaceState: function(publicInstance) { 375 warnNoop(publicInstance, "replaceState"); 376 }, 377 enqueueSetState: function(publicInstance) { 378 warnNoop(publicInstance, "setState"); 379 } 380 }, assign = Object.assign, emptyObject = {}; 381 Object.freeze(emptyObject); 382 Component.prototype.isReactComponent = {}; 383 Component.prototype.setState = function(partialState, callback) { 384 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."); 385 this.updater.enqueueSetState(this, partialState, callback, "setState"); 386 }; 387 Component.prototype.forceUpdate = function(callback) { 388 this.updater.enqueueForceUpdate(this, callback, "forceUpdate"); 389 }; 390 var deprecatedAPIs = { 391 isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],
vendor: 18,386 bytes, lines 392-769
392 replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."] 393 }; 394 for (fnName in deprecatedAPIs) deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); 395 ComponentDummy.prototype = Component.prototype; 396 deprecatedAPIs = PureComponent.prototype = new ComponentDummy(); 397 deprecatedAPIs.constructor = PureComponent; 398 assign(deprecatedAPIs, Component.prototype); 399 deprecatedAPIs.isPureReactComponent = !0; 400 var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = { 401 H: null, 402 A: null, 403 T: null, 404 S: null, 405 actQueue: null, 406 asyncTransitions: 0, 407 isBatchingLegacy: !1, 408 didScheduleLegacyUpdate: !1, 409 didUsePromise: !1, 410 thrownErrors: [], 411 getCurrentStack: null, 412 recentlyCreatedOwnerStacks: 0 413 }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() { 414 return null; 415 }; 416 deprecatedAPIs = { react_stack_bottom_frame: function(callStackForError) { 417 return callStackForError(); 418 } }; 419 var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime; 420 var didWarnAboutElementRef = {}; 421 var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(deprecatedAPIs, UnknownOwner)(); 422 var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner)); 423 var didWarnAboutMaps = !1, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = "function" === typeof reportError ? reportError : function(error) { 424 if ("object" === typeof window && "function" === typeof window.ErrorEvent) { 425 var event = new window.ErrorEvent("error", { 426 bubbles: !0, 427 cancelable: !0, 428 message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error), 429 error 430 }); 431 if (!window.dispatchEvent(event)) return; 432 } else if ("object" === typeof process && "function" === typeof process.emit) { 433 process.emit("uncaughtException", error); 434 return; 435 } 436 console.error(error); 437 }, didWarnAboutMessageChannel = !1, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = !1, isFlushing = !1, queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function(callback) { 438 queueMicrotask(function() { 439 return queueMicrotask(callback); 440 }); 441 } : enqueueTask; 442 deprecatedAPIs = Object.freeze({ 443 __proto__: null, 444 c: function(size) { 445 return resolveDispatcher().useMemoCache(size); 446 } 447 }); 448 var fnName = { 449 map: mapChildren, 450 forEach: function(children, forEachFunc, forEachContext) { 451 mapChildren(children, function() { 452 forEachFunc.apply(this, arguments); 453 }, forEachContext); 454 }, 455 count: function(children) { 456 var n = 0; 457 mapChildren(children, function() { 458 n++; 459 }); 460 return n; 461 }, 462 toArray: function(children) { 463 return mapChildren(children, function(child) { 464 return child; 465 }) || []; 466 }, 467 only: function(children) { 468 if (!isValidElement(children)) throw Error("React.Children.only expected to receive a single React element child."); 469 return children; 470 } 471 }; 472 exports.Activity = REACT_ACTIVITY_TYPE; 473 exports.Children = fnName; 474 exports.Component = Component; 475 exports.Fragment = REACT_FRAGMENT_TYPE; 476 exports.Profiler = REACT_PROFILER_TYPE; 477 exports.PureComponent = PureComponent; 478 exports.StrictMode = REACT_STRICT_MODE_TYPE; 479 exports.Suspense = REACT_SUSPENSE_TYPE; 480 exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals; 481 exports.__COMPILER_RUNTIME = deprecatedAPIs; 482 exports.act = function(callback) { 483 var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth; 484 actScopeDepth++; 485 var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = !1; 486 try { 487 var result = callback(); 488 } catch (error) { 489 ReactSharedInternals.thrownErrors.push(error); 490 } 491 if (0 < ReactSharedInternals.thrownErrors.length) throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback; 492 if (null !== result && "object" === typeof result && "function" === typeof result.then) { 493 var thenable = result; 494 queueSeveralMicrotasks(function() { 495 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 () => ...);")); 496 }); 497 return { then: function(resolve, reject) { 498 didAwaitActCall = !0; 499 thenable.then(function(returnValue) { 500 popActScope(prevActQueue, prevActScopeDepth); 501 if (0 === prevActScopeDepth) { 502 try { 503 flushActQueue(queue), enqueueTask(function() { 504 return recursivelyFlushAsyncActWork(returnValue, resolve, reject); 505 }); 506 } catch (error$0) { 507 ReactSharedInternals.thrownErrors.push(error$0); 508 } 509 if (0 < ReactSharedInternals.thrownErrors.length) { 510 var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors); 511 ReactSharedInternals.thrownErrors.length = 0; 512 reject(_thrownError); 513 } 514 } else resolve(returnValue); 515 }, function(error) { 516 popActScope(prevActQueue, prevActScopeDepth); 517 0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error); 518 }); 519 } }; 520 } 521 var returnValue$jscomp$0 = result; 522 popActScope(prevActQueue, prevActScopeDepth); 523 0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function() { 524 didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("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(() => ...)")); 525 }), ReactSharedInternals.actQueue = null); 526 if (0 < ReactSharedInternals.thrownErrors.length) throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback; 527 return { then: function(resolve, reject) { 528 didAwaitActCall = !0; 529 0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() { 530 return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject); 531 })) : resolve(returnValue$jscomp$0); 532 } }; 533 }; 534 exports.cache = function(fn) { 535 return function() { 536 return fn.apply(null, arguments); 537 }; 538 }; 539 exports.cacheSignal = function() { 540 return null; 541 }; 542 exports.captureOwnerStack = function() { 543 var getCurrentStack = ReactSharedInternals.getCurrentStack; 544 return null === getCurrentStack ? null : getCurrentStack(); 545 }; 546 exports.cloneElement = function(element, config, children) { 547 if (null === element || void 0 === element) throw Error("The argument must be a React element, but you passed " + element + "."); 548 var props = assign({}, element.props), key = element.key, owner = element._owner; 549 if (null != config) { 550 var JSCompiler_inline_result; 551 a: { 552 if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(config, "ref").get) && JSCompiler_inline_result.isReactWarning) { 553 JSCompiler_inline_result = !1; 554 break a; 555 } 556 JSCompiler_inline_result = void 0 !== config.ref; 557 } 558 JSCompiler_inline_result && (owner = getOwner()); 559 hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key); 560 for (propName in config) !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]); 561 } 562 var propName = arguments.length - 2; 563 if (1 === propName) props.children = children; 564 else if (1 < propName) { 565 JSCompiler_inline_result = Array(propName); 566 for (var i = 0; i < propName; i++) JSCompiler_inline_result[i] = arguments[i + 2]; 567 props.children = JSCompiler_inline_result; 568 } 569 props = ReactElement(element.type, key, props, owner, element._debugStack, element._debugTask); 570 for (key = 2; key < arguments.length; key++) validateChildKeys(arguments[key]); 571 return props; 572 }; 573 exports.createContext = function(defaultValue) { 574 defaultValue = { 575 $$typeof: REACT_CONTEXT_TYPE, 576 _currentValue: defaultValue, 577 _currentValue2: defaultValue, 578 _threadCount: 0, 579 Provider: null, 580 Consumer: null 581 }; 582 defaultValue.Provider = defaultValue; 583 defaultValue.Consumer = { 584 $$typeof: REACT_CONSUMER_TYPE, 585 _context: defaultValue 586 }; 587 defaultValue._currentRenderer = null; 588 defaultValue._currentRenderer2 = null; 589 return defaultValue; 590 }; 591 exports.createElement = function(type, config, children) { 592 for (var i = 2; i < arguments.length; i++) validateChildKeys(arguments[i]); 593 i = {}; 594 var key = null; 595 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]); 596 var childrenLength = arguments.length - 2; 597 if (1 === childrenLength) i.children = children; 598 else if (1 < childrenLength) { 599 for (var childArray = Array(childrenLength), _i = 0; _i < childrenLength; _i++) childArray[_i] = arguments[_i + 2]; 600 Object.freeze && Object.freeze(childArray); 601 i.children = childArray; 602 } 603 if (type && type.defaultProps) for (propName in childrenLength = type.defaultProps, childrenLength) void 0 === i[propName] && (i[propName] = childrenLength[propName]); 604 key && defineKeyPropWarningGetter(i, "function" === typeof type ? type.displayName || type.name || "Unknown" : type); 605 var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++; 606 return ReactElement(type, key, i, getOwner(), propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack, propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask); 607 }; 608 exports.createRef = function() { 609 var refObject = { current: null }; 610 Object.seal(refObject); 611 return refObject; 612 }; 613 exports.forwardRef = function(render) { 614 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."); 615 null != render && null != render.defaultProps && console.error("forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"); 616 var elementType = { 617 $$typeof: REACT_FORWARD_REF_TYPE, 618 render 619 }, ownName; 620 Object.defineProperty(elementType, "displayName", { 621 enumerable: !1, 622 configurable: !0, 623 get: function() { 624 return ownName; 625 }, 626 set: function(name) { 627 ownName = name; 628 render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name); 629 } 630 }); 631 return elementType; 632 }; 633 exports.isValidElement = isValidElement; 634 exports.lazy = function(ctor) { 635 ctor = { 636 _status: -1, 637 _result: ctor 638 }; 639 var lazyType = { 640 $$typeof: REACT_LAZY_TYPE, 641 _payload: ctor, 642 _init: lazyInitializer 643 }, ioInfo = { 644 name: "lazy", 645 start: -1, 646 end: -1, 647 value: null, 648 owner: null, 649 debugStack: Error("react-stack-top-frame"), 650 debugTask: console.createTask ? console.createTask("lazy()") : null 651 }; 652 ctor._ioInfo = ioInfo; 653 lazyType._debugInfo = [{ awaited: ioInfo }]; 654 return lazyType; 655 }; 656 exports.memo = function(type, compare) { 657 type ?? console.error("memo: The first argument must be a component. Instead received: %s", null === type ? "null" : typeof type); 658 compare = { 659 $$typeof: REACT_MEMO_TYPE, 660 type, 661 compare: void 0 === compare ? null : compare 662 }; 663 var ownName; 664 Object.defineProperty(compare, "displayName", { 665 enumerable: !1, 666 configurable: !0, 667 get: function() { 668 return ownName; 669 }, 670 set: function(name) { 671 ownName = name; 672 type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name); 673 } 674 }); 675 return compare; 676 }; 677 exports.startTransition = function(scope) { 678 var prevTransition = ReactSharedInternals.T, currentTransition = {}; 679 currentTransition._updatedFibers = /* @__PURE__ */ new Set(); 680 ReactSharedInternals.T = currentTransition; 681 try { 682 var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S; 683 null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue); 684 "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError)); 685 } catch (error) { 686 reportGlobalError(error); 687 } finally { 688 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; 689 } 690 }; 691 exports.unstable_useCacheRefresh = function() { 692 return resolveDispatcher().useCacheRefresh(); 693 }; 694 exports.use = function(usable) { 695 return resolveDispatcher().use(usable); 696 }; 697 exports.useActionState = function(action, initialState, permalink) { 698 return resolveDispatcher().useActionState(action, initialState, permalink); 699 }; 700 exports.useCallback = function(callback, deps) { 701 return resolveDispatcher().useCallback(callback, deps); 702 }; 703 exports.useContext = function(Context) { 704 var dispatcher = resolveDispatcher(); 705 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?"); 706 return dispatcher.useContext(Context); 707 }; 708 exports.useDebugValue = function(value, formatterFn) { 709 return resolveDispatcher().useDebugValue(value, formatterFn); 710 }; 711 exports.useDeferredValue = function(value, initialValue) { 712 return resolveDispatcher().useDeferredValue(value, initialValue); 713 }; 714 exports.useEffect = function(create, deps) { 715 create ?? console.warn("React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"); 716 return resolveDispatcher().useEffect(create, deps); 717 }; 718 exports.useEffectEvent = function(callback) { 719 return resolveDispatcher().useEffectEvent(callback); 720 }; 721 exports.useId = function() { 722 return resolveDispatcher().useId(); 723 }; 724 exports.useImperativeHandle = function(ref, create, deps) { 725 return resolveDispatcher().useImperativeHandle(ref, create, deps); 726 }; 727 exports.useInsertionEffect = function(create, deps) { 728 create ?? console.warn("React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"); 729 return resolveDispatcher().useInsertionEffect(create, deps); 730 }; 731 exports.useLayoutEffect = function(create, deps) { 732 create ?? console.warn("React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"); 733 return resolveDispatcher().useLayoutEffect(create, deps); 734 }; 735 exports.useMemo = function(create, deps) { 736 return resolveDispatcher().useMemo(create, deps); 737 }; 738 exports.useOptimistic = function(passthrough, reducer) { 739 return resolveDispatcher().useOptimistic(passthrough, reducer); 740 }; 741 exports.useReducer = function(reducer, initialArg, init) { 742 return resolveDispatcher().useReducer(reducer, initialArg, init); 743 }; 744 exports.useRef = function(initialValue) { 745 return resolveDispatcher().useRef(initialValue); 746 }; 747 exports.useState = function(initialState) { 748 return resolveDispatcher().useState(initialState); 749 }; 750 exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) { 751 return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot); 752 }; 753 exports.useTransition = function() { 754 return resolveDispatcher().useTransition(); 755 }; 756 exports.version = "19.2.4"; 757 "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error()); 758 })(); 759})); 760//#endregion 761//#region node_modules/react/index.js 762var require_react = /* @__PURE__ */ __commonJSMin(((exports, module) => { 763 module.exports = require_react_development(); 764})); 765//#endregion 766export default require_react(); 767export { require_react as t }; 768 769//# sourceMappingURL=react.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.