| 1 |
(() => { |
| 2 |
var __getOwnPropNames = Object.getOwnPropertyNames; |
| 3 |
var __commonJS = (cb, mod) => function __require() { |
| 4 |
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; |
| 5 |
}; |
| 6 |
|
| 7 |
// node_modules/core-js-pure/internals/global.js |
| 8 |
var require_global = __commonJS({ |
| 9 |
"node_modules/core-js-pure/internals/global.js"(exports, module) { |
| 10 |
var check = function(it) { |
| 11 |
return it && it.Math == Math && it; |
| 12 |
}; |
| 13 |
module.exports = // eslint-disable-next-line es/no-global-this -- safe |
| 14 |
check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || // eslint-disable-next-line no-restricted-globals -- safe |
| 15 |
check(typeof self == "object" && self) || check(typeof global == "object" && global) || // eslint-disable-next-line no-new-func -- fallback |
| 16 |
/* @__PURE__ */ (function() { |
| 17 |
return this; |
| 18 |
})() || exports || Function("return this")(); |
| 19 |
} |
| 20 |
}); |
| 21 |
|
| 22 |
// node_modules/core-js-pure/internals/fails.js |
| 23 |
var require_fails = __commonJS({ |
| 24 |
"node_modules/core-js-pure/internals/fails.js"(exports, module) { |
| 25 |
module.exports = function(exec) { |
| 26 |
try { |
| 27 |
return !!exec(); |
| 28 |
} catch (error) { |
| 29 |
return true; |
| 30 |
} |
| 31 |
}; |
| 32 |
} |
| 33 |
}); |
| 34 |
|
| 35 |
// node_modules/core-js-pure/internals/function-bind-native.js |
| 36 |
var require_function_bind_native = __commonJS({ |
| 37 |
"node_modules/core-js-pure/internals/function-bind-native.js"(exports, module) { |
| 38 |
var fails = require_fails(); |
| 39 |
module.exports = !fails(function() { |
| 40 |
var test = (function() { |
| 41 |
}).bind(); |
| 42 |
return typeof test != "function" || test.hasOwnProperty("prototype"); |
| 43 |
}); |
| 44 |
} |
| 45 |
}); |
| 46 |
|
| 47 |
// node_modules/core-js-pure/internals/function-apply.js |
| 48 |
var require_function_apply = __commonJS({ |
| 49 |
"node_modules/core-js-pure/internals/function-apply.js"(exports, module) { |
| 50 |
var NATIVE_BIND = require_function_bind_native(); |
| 51 |
var FunctionPrototype = Function.prototype; |
| 52 |
var apply = FunctionPrototype.apply; |
| 53 |
var call = FunctionPrototype.call; |
| 54 |
module.exports = typeof Reflect == "object" && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function() { |
| 55 |
return call.apply(apply, arguments); |
| 56 |
}); |
| 57 |
} |
| 58 |
}); |
| 59 |
|
| 60 |
// node_modules/core-js-pure/internals/function-uncurry-this.js |
| 61 |
var require_function_uncurry_this = __commonJS({ |
| 62 |
"node_modules/core-js-pure/internals/function-uncurry-this.js"(exports, module) { |
| 63 |
var NATIVE_BIND = require_function_bind_native(); |
| 64 |
var FunctionPrototype = Function.prototype; |
| 65 |
var call = FunctionPrototype.call; |
| 66 |
var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call); |
| 67 |
module.exports = NATIVE_BIND ? uncurryThisWithBind : function(fn) { |
| 68 |
return function() { |
| 69 |
return call.apply(fn, arguments); |
| 70 |
}; |
| 71 |
}; |
| 72 |
} |
| 73 |
}); |
| 74 |
|
| 75 |
// node_modules/core-js-pure/internals/classof-raw.js |
| 76 |
var require_classof_raw = __commonJS({ |
| 77 |
"node_modules/core-js-pure/internals/classof-raw.js"(exports, module) { |
| 78 |
var uncurryThis = require_function_uncurry_this(); |
| 79 |
var toString = uncurryThis({}.toString); |
| 80 |
var stringSlice = uncurryThis("".slice); |
| 81 |
module.exports = function(it) { |
| 82 |
return stringSlice(toString(it), 8, -1); |
| 83 |
}; |
| 84 |
} |
| 85 |
}); |
| 86 |
|
| 87 |
// node_modules/core-js-pure/internals/function-uncurry-this-clause.js |
| 88 |
var require_function_uncurry_this_clause = __commonJS({ |
| 89 |
"node_modules/core-js-pure/internals/function-uncurry-this-clause.js"(exports, module) { |
| 90 |
var classofRaw = require_classof_raw(); |
| 91 |
var uncurryThis = require_function_uncurry_this(); |
| 92 |
module.exports = function(fn) { |
| 93 |
if (classofRaw(fn) === "Function") return uncurryThis(fn); |
| 94 |
}; |
| 95 |
} |
| 96 |
}); |
| 97 |
|
| 98 |
// node_modules/core-js-pure/internals/document-all.js |
| 99 |
var require_document_all = __commonJS({ |
| 100 |
"node_modules/core-js-pure/internals/document-all.js"(exports, module) { |
| 101 |
var documentAll = typeof document == "object" && document.all; |
| 102 |
var IS_HTMLDDA = typeof documentAll == "undefined" && documentAll !== void 0; |
| 103 |
module.exports = { |
| 104 |
all: documentAll, |
| 105 |
IS_HTMLDDA |
| 106 |
}; |
| 107 |
} |
| 108 |
}); |
| 109 |
|
| 110 |
// node_modules/core-js-pure/internals/is-callable.js |
| 111 |
var require_is_callable = __commonJS({ |
| 112 |
"node_modules/core-js-pure/internals/is-callable.js"(exports, module) { |
| 113 |
var $documentAll = require_document_all(); |
| 114 |
var documentAll = $documentAll.all; |
| 115 |
module.exports = $documentAll.IS_HTMLDDA ? function(argument) { |
| 116 |
return typeof argument == "function" || argument === documentAll; |
| 117 |
} : function(argument) { |
| 118 |
return typeof argument == "function"; |
| 119 |
}; |
| 120 |
} |
| 121 |
}); |
| 122 |
|
| 123 |
// node_modules/core-js-pure/internals/descriptors.js |
| 124 |
var require_descriptors = __commonJS({ |
| 125 |
"node_modules/core-js-pure/internals/descriptors.js"(exports, module) { |
| 126 |
var fails = require_fails(); |
| 127 |
module.exports = !fails(function() { |
| 128 |
return Object.defineProperty({}, 1, { get: function() { |
| 129 |
return 7; |
| 130 |
} })[1] != 7; |
| 131 |
}); |
| 132 |
} |
| 133 |
}); |
| 134 |
|
| 135 |
// node_modules/core-js-pure/internals/function-call.js |
| 136 |
var require_function_call = __commonJS({ |
| 137 |
"node_modules/core-js-pure/internals/function-call.js"(exports, module) { |
| 138 |
var NATIVE_BIND = require_function_bind_native(); |
| 139 |
var call = Function.prototype.call; |
| 140 |
module.exports = NATIVE_BIND ? call.bind(call) : function() { |
| 141 |
return call.apply(call, arguments); |
| 142 |
}; |
| 143 |
} |
| 144 |
}); |
| 145 |
|
| 146 |
// node_modules/core-js-pure/internals/object-property-is-enumerable.js |
| 147 |
var require_object_property_is_enumerable = __commonJS({ |
| 148 |
"node_modules/core-js-pure/internals/object-property-is-enumerable.js"(exports) { |
| 149 |
"use strict"; |
| 150 |
var $propertyIsEnumerable = {}.propertyIsEnumerable; |
| 151 |
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; |
| 152 |
var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1); |
| 153 |
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { |
| 154 |
var descriptor = getOwnPropertyDescriptor(this, V); |
| 155 |
return !!descriptor && descriptor.enumerable; |
| 156 |
} : $propertyIsEnumerable; |
| 157 |
} |
| 158 |
}); |
| 159 |
|
| 160 |
// node_modules/core-js-pure/internals/create-property-descriptor.js |
| 161 |
var require_create_property_descriptor = __commonJS({ |
| 162 |
"node_modules/core-js-pure/internals/create-property-descriptor.js"(exports, module) { |
| 163 |
module.exports = function(bitmap, value) { |
| 164 |
return { |
| 165 |
enumerable: !(bitmap & 1), |
| 166 |
configurable: !(bitmap & 2), |
| 167 |
writable: !(bitmap & 4), |
| 168 |
value |
| 169 |
}; |
| 170 |
}; |
| 171 |
} |
| 172 |
}); |
| 173 |
|
| 174 |
// node_modules/core-js-pure/internals/indexed-object.js |
| 175 |
var require_indexed_object = __commonJS({ |
| 176 |
"node_modules/core-js-pure/internals/indexed-object.js"(exports, module) { |
| 177 |
var uncurryThis = require_function_uncurry_this(); |
| 178 |
var fails = require_fails(); |
| 179 |
var classof = require_classof_raw(); |
| 180 |
var $Object = Object; |
| 181 |
var split = uncurryThis("".split); |
| 182 |
module.exports = fails(function() { |
| 183 |
return !$Object("z").propertyIsEnumerable(0); |
| 184 |
}) ? function(it) { |
| 185 |
return classof(it) == "String" ? split(it, "") : $Object(it); |
| 186 |
} : $Object; |
| 187 |
} |
| 188 |
}); |
| 189 |
|
| 190 |
// node_modules/core-js-pure/internals/is-null-or-undefined.js |
| 191 |
var require_is_null_or_undefined = __commonJS({ |
| 192 |
"node_modules/core-js-pure/internals/is-null-or-undefined.js"(exports, module) { |
| 193 |
module.exports = function(it) { |
| 194 |
return it === null || it === void 0; |
| 195 |
}; |
| 196 |
} |
| 197 |
}); |
| 198 |
|
| 199 |
// node_modules/core-js-pure/internals/require-object-coercible.js |
| 200 |
var require_require_object_coercible = __commonJS({ |
| 201 |
"node_modules/core-js-pure/internals/require-object-coercible.js"(exports, module) { |
| 202 |
var isNullOrUndefined = require_is_null_or_undefined(); |
| 203 |
var $TypeError = TypeError; |
| 204 |
module.exports = function(it) { |
| 205 |
if (isNullOrUndefined(it)) throw $TypeError("Can't call method on " + it); |
| 206 |
return it; |
| 207 |
}; |
| 208 |
} |
| 209 |
}); |
| 210 |
|
| 211 |
// node_modules/core-js-pure/internals/to-indexed-object.js |
| 212 |
var require_to_indexed_object = __commonJS({ |
| 213 |
"node_modules/core-js-pure/internals/to-indexed-object.js"(exports, module) { |
| 214 |
var IndexedObject = require_indexed_object(); |
| 215 |
var requireObjectCoercible = require_require_object_coercible(); |
| 216 |
module.exports = function(it) { |
| 217 |
return IndexedObject(requireObjectCoercible(it)); |
| 218 |
}; |
| 219 |
} |
| 220 |
}); |
| 221 |
|
| 222 |
// node_modules/core-js-pure/internals/is-object.js |
| 223 |
var require_is_object = __commonJS({ |
| 224 |
"node_modules/core-js-pure/internals/is-object.js"(exports, module) { |
| 225 |
var isCallable = require_is_callable(); |
| 226 |
var $documentAll = require_document_all(); |
| 227 |
var documentAll = $documentAll.all; |
| 228 |
module.exports = $documentAll.IS_HTMLDDA ? function(it) { |
| 229 |
return typeof it == "object" ? it !== null : isCallable(it) || it === documentAll; |
| 230 |
} : function(it) { |
| 231 |
return typeof it == "object" ? it !== null : isCallable(it); |
| 232 |
}; |
| 233 |
} |
| 234 |
}); |
| 235 |
|
| 236 |
// node_modules/core-js-pure/internals/path.js |
| 237 |
var require_path = __commonJS({ |
| 238 |
"node_modules/core-js-pure/internals/path.js"(exports, module) { |
| 239 |
module.exports = {}; |
| 240 |
} |
| 241 |
}); |
| 242 |
|
| 243 |
// node_modules/core-js-pure/internals/get-built-in.js |
| 244 |
var require_get_built_in = __commonJS({ |
| 245 |
"node_modules/core-js-pure/internals/get-built-in.js"(exports, module) { |
| 246 |
var path = require_path(); |
| 247 |
var global2 = require_global(); |
| 248 |
var isCallable = require_is_callable(); |
| 249 |
var aFunction = function(variable) { |
| 250 |
return isCallable(variable) ? variable : void 0; |
| 251 |
}; |
| 252 |
module.exports = function(namespace, method) { |
| 253 |
return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global2[namespace]) : path[namespace] && path[namespace][method] || global2[namespace] && global2[namespace][method]; |
| 254 |
}; |
| 255 |
} |
| 256 |
}); |
| 257 |
|
| 258 |
// node_modules/core-js-pure/internals/object-is-prototype-of.js |
| 259 |
var require_object_is_prototype_of = __commonJS({ |
| 260 |
"node_modules/core-js-pure/internals/object-is-prototype-of.js"(exports, module) { |
| 261 |
var uncurryThis = require_function_uncurry_this(); |
| 262 |
module.exports = uncurryThis({}.isPrototypeOf); |
| 263 |
} |
| 264 |
}); |
| 265 |
|
| 266 |
// node_modules/core-js-pure/internals/engine-user-agent.js |
| 267 |
var require_engine_user_agent = __commonJS({ |
| 268 |
"node_modules/core-js-pure/internals/engine-user-agent.js"(exports, module) { |
| 269 |
module.exports = typeof navigator != "undefined" && String(navigator.userAgent) || ""; |
| 270 |
} |
| 271 |
}); |
| 272 |
|
| 273 |
// node_modules/core-js-pure/internals/engine-v8-version.js |
| 274 |
var require_engine_v8_version = __commonJS({ |
| 275 |
"node_modules/core-js-pure/internals/engine-v8-version.js"(exports, module) { |
| 276 |
var global2 = require_global(); |
| 277 |
var userAgent = require_engine_user_agent(); |
| 278 |
var process2 = global2.process; |
| 279 |
var Deno = global2.Deno; |
| 280 |
var versions = process2 && process2.versions || Deno && Deno.version; |
| 281 |
var v8 = versions && versions.v8; |
| 282 |
var match; |
| 283 |
var version; |
| 284 |
if (v8) { |
| 285 |
match = v8.split("."); |
| 286 |
version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); |
| 287 |
} |
| 288 |
if (!version && userAgent) { |
| 289 |
match = userAgent.match(/Edge\/(\d+)/); |
| 290 |
if (!match || match[1] >= 74) { |
| 291 |
match = userAgent.match(/Chrome\/(\d+)/); |
| 292 |
if (match) version = +match[1]; |
| 293 |
} |
| 294 |
} |
| 295 |
module.exports = version; |
| 296 |
} |
| 297 |
}); |
| 298 |
|
| 299 |
// node_modules/core-js-pure/internals/symbol-constructor-detection.js |
| 300 |
var require_symbol_constructor_detection = __commonJS({ |
| 301 |
"node_modules/core-js-pure/internals/symbol-constructor-detection.js"(exports, module) { |
| 302 |
var V8_VERSION = require_engine_v8_version(); |
| 303 |
var fails = require_fails(); |
| 304 |
var global2 = require_global(); |
| 305 |
var $String = global2.String; |
| 306 |
module.exports = !!Object.getOwnPropertySymbols && !fails(function() { |
| 307 |
var symbol = Symbol(); |
| 308 |
return !$String(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances |
| 309 |
!Symbol.sham && V8_VERSION && V8_VERSION < 41; |
| 310 |
}); |
| 311 |
} |
| 312 |
}); |
| 313 |
|
| 314 |
// node_modules/core-js-pure/internals/use-symbol-as-uid.js |
| 315 |
var require_use_symbol_as_uid = __commonJS({ |
| 316 |
"node_modules/core-js-pure/internals/use-symbol-as-uid.js"(exports, module) { |
| 317 |
var NATIVE_SYMBOL = require_symbol_constructor_detection(); |
| 318 |
module.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == "symbol"; |
| 319 |
} |
| 320 |
}); |
| 321 |
|
| 322 |
// node_modules/core-js-pure/internals/is-symbol.js |
| 323 |
var require_is_symbol = __commonJS({ |
| 324 |
"node_modules/core-js-pure/internals/is-symbol.js"(exports, module) { |
| 325 |
var getBuiltIn = require_get_built_in(); |
| 326 |
var isCallable = require_is_callable(); |
| 327 |
var isPrototypeOf = require_object_is_prototype_of(); |
| 328 |
var USE_SYMBOL_AS_UID = require_use_symbol_as_uid(); |
| 329 |
var $Object = Object; |
| 330 |
module.exports = USE_SYMBOL_AS_UID ? function(it) { |
| 331 |
return typeof it == "symbol"; |
| 332 |
} : function(it) { |
| 333 |
var $Symbol = getBuiltIn("Symbol"); |
| 334 |
return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it)); |
| 335 |
}; |
| 336 |
} |
| 337 |
}); |
| 338 |
|
| 339 |
// node_modules/core-js-pure/internals/try-to-string.js |
| 340 |
var require_try_to_string = __commonJS({ |
| 341 |
"node_modules/core-js-pure/internals/try-to-string.js"(exports, module) { |
| 342 |
var $String = String; |
| 343 |
module.exports = function(argument) { |
| 344 |
try { |
| 345 |
return $String(argument); |
| 346 |
} catch (error) { |
| 347 |
return "Object"; |
| 348 |
} |
| 349 |
}; |
| 350 |
} |
| 351 |
}); |
| 352 |
|
| 353 |
// node_modules/core-js-pure/internals/a-callable.js |
| 354 |
var require_a_callable = __commonJS({ |
| 355 |
"node_modules/core-js-pure/internals/a-callable.js"(exports, module) { |
| 356 |
var isCallable = require_is_callable(); |
| 357 |
var tryToString = require_try_to_string(); |
| 358 |
var $TypeError = TypeError; |
| 359 |
module.exports = function(argument) { |
| 360 |
if (isCallable(argument)) return argument; |
| 361 |
throw $TypeError(tryToString(argument) + " is not a function"); |
| 362 |
}; |
| 363 |
} |
| 364 |
}); |
| 365 |
|
| 366 |
// node_modules/core-js-pure/internals/get-method.js |
| 367 |
var require_get_method = __commonJS({ |
| 368 |
"node_modules/core-js-pure/internals/get-method.js"(exports, module) { |
| 369 |
var aCallable = require_a_callable(); |
| 370 |
var isNullOrUndefined = require_is_null_or_undefined(); |
| 371 |
module.exports = function(V, P) { |
| 372 |
var func = V[P]; |
| 373 |
return isNullOrUndefined(func) ? void 0 : aCallable(func); |
| 374 |
}; |
| 375 |
} |
| 376 |
}); |
| 377 |
|
| 378 |
// node_modules/core-js-pure/internals/ordinary-to-primitive.js |
| 379 |
var require_ordinary_to_primitive = __commonJS({ |
| 380 |
"node_modules/core-js-pure/internals/ordinary-to-primitive.js"(exports, module) { |
| 381 |
var call = require_function_call(); |
| 382 |
var isCallable = require_is_callable(); |
| 383 |
var isObject = require_is_object(); |
| 384 |
var $TypeError = TypeError; |
| 385 |
module.exports = function(input, pref) { |
| 386 |
var fn, val; |
| 387 |
if (pref === "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val; |
| 388 |
if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val; |
| 389 |
if (pref !== "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val; |
| 390 |
throw $TypeError("Can't convert object to primitive value"); |
| 391 |
}; |
| 392 |
} |
| 393 |
}); |
| 394 |
|
| 395 |
// node_modules/core-js-pure/internals/is-pure.js |
| 396 |
var require_is_pure = __commonJS({ |
| 397 |
"node_modules/core-js-pure/internals/is-pure.js"(exports, module) { |
| 398 |
module.exports = true; |
| 399 |
} |
| 400 |
}); |
| 401 |
|
| 402 |
// node_modules/core-js-pure/internals/define-global-property.js |
| 403 |
var require_define_global_property = __commonJS({ |
| 404 |
"node_modules/core-js-pure/internals/define-global-property.js"(exports, module) { |
| 405 |
var global2 = require_global(); |
| 406 |
var defineProperty = Object.defineProperty; |
| 407 |
module.exports = function(key, value) { |
| 408 |
try { |
| 409 |
defineProperty(global2, key, { value, configurable: true, writable: true }); |
| 410 |
} catch (error) { |
| 411 |
global2[key] = value; |
| 412 |
} |
| 413 |
return value; |
| 414 |
}; |
| 415 |
} |
| 416 |
}); |
| 417 |
|
| 418 |
// node_modules/core-js-pure/internals/shared-store.js |
| 419 |
var require_shared_store = __commonJS({ |
| 420 |
"node_modules/core-js-pure/internals/shared-store.js"(exports, module) { |
| 421 |
var global2 = require_global(); |
| 422 |
var defineGlobalProperty = require_define_global_property(); |
| 423 |
var SHARED = "__core-js_shared__"; |
| 424 |
var store = global2[SHARED] || defineGlobalProperty(SHARED, {}); |
| 425 |
module.exports = store; |
| 426 |
} |
| 427 |
}); |
| 428 |
|
| 429 |
// node_modules/core-js-pure/internals/shared.js |
| 430 |
var require_shared = __commonJS({ |
| 431 |
"node_modules/core-js-pure/internals/shared.js"(exports, module) { |
| 432 |
var IS_PURE = require_is_pure(); |
| 433 |
var store = require_shared_store(); |
| 434 |
(module.exports = function(key, value) { |
| 435 |
return store[key] || (store[key] = value !== void 0 ? value : {}); |
| 436 |
})("versions", []).push({ |
| 437 |
version: "3.31.0", |
| 438 |
mode: IS_PURE ? "pure" : "global", |
| 439 |
copyright: "\xA9 2014-2023 Denis Pushkarev (zloirock.ru)", |
| 440 |
license: "https://github.com/zloirock/core-js/blob/v3.31.0/LICENSE", |
| 441 |
source: "https://github.com/zloirock/core-js" |
| 442 |
}); |
| 443 |
} |
| 444 |
}); |
| 445 |
|
| 446 |
// node_modules/core-js-pure/internals/to-object.js |
| 447 |
var require_to_object = __commonJS({ |
| 448 |
"node_modules/core-js-pure/internals/to-object.js"(exports, module) { |
| 449 |
var requireObjectCoercible = require_require_object_coercible(); |
| 450 |
var $Object = Object; |
| 451 |
module.exports = function(argument) { |
| 452 |
return $Object(requireObjectCoercible(argument)); |
| 453 |
}; |
| 454 |
} |
| 455 |
}); |
| 456 |
|
| 457 |
// node_modules/core-js-pure/internals/has-own-property.js |
| 458 |
var require_has_own_property = __commonJS({ |
| 459 |
"node_modules/core-js-pure/internals/has-own-property.js"(exports, module) { |
| 460 |
var uncurryThis = require_function_uncurry_this(); |
| 461 |
var toObject = require_to_object(); |
| 462 |
var hasOwnProperty = uncurryThis({}.hasOwnProperty); |
| 463 |
module.exports = Object.hasOwn || function hasOwn(it, key) { |
| 464 |
return hasOwnProperty(toObject(it), key); |
| 465 |
}; |
| 466 |
} |
| 467 |
}); |
| 468 |
|
| 469 |
// node_modules/core-js-pure/internals/uid.js |
| 470 |
var require_uid = __commonJS({ |
| 471 |
"node_modules/core-js-pure/internals/uid.js"(exports, module) { |
| 472 |
var uncurryThis = require_function_uncurry_this(); |
| 473 |
var id = 0; |
| 474 |
var postfix = Math.random(); |
| 475 |
var toString = uncurryThis(1 .toString); |
| 476 |
module.exports = function(key) { |
| 477 |
return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString(++id + postfix, 36); |
| 478 |
}; |
| 479 |
} |
| 480 |
}); |
| 481 |
|
| 482 |
// node_modules/core-js-pure/internals/well-known-symbol.js |
| 483 |
var require_well_known_symbol = __commonJS({ |
| 484 |
"node_modules/core-js-pure/internals/well-known-symbol.js"(exports, module) { |
| 485 |
var global2 = require_global(); |
| 486 |
var shared = require_shared(); |
| 487 |
var hasOwn = require_has_own_property(); |
| 488 |
var uid = require_uid(); |
| 489 |
var NATIVE_SYMBOL = require_symbol_constructor_detection(); |
| 490 |
var USE_SYMBOL_AS_UID = require_use_symbol_as_uid(); |
| 491 |
var Symbol2 = global2.Symbol; |
| 492 |
var WellKnownSymbolsStore = shared("wks"); |
| 493 |
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol2["for"] || Symbol2 : Symbol2 && Symbol2.withoutSetter || uid; |
| 494 |
module.exports = function(name) { |
| 495 |
if (!hasOwn(WellKnownSymbolsStore, name)) { |
| 496 |
WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol2, name) ? Symbol2[name] : createWellKnownSymbol("Symbol." + name); |
| 497 |
} |
| 498 |
return WellKnownSymbolsStore[name]; |
| 499 |
}; |
| 500 |
} |
| 501 |
}); |
| 502 |
|
| 503 |
// node_modules/core-js-pure/internals/to-primitive.js |
| 504 |
var require_to_primitive = __commonJS({ |
| 505 |
"node_modules/core-js-pure/internals/to-primitive.js"(exports, module) { |
| 506 |
var call = require_function_call(); |
| 507 |
var isObject = require_is_object(); |
| 508 |
var isSymbol = require_is_symbol(); |
| 509 |
var getMethod = require_get_method(); |
| 510 |
var ordinaryToPrimitive = require_ordinary_to_primitive(); |
| 511 |
var wellKnownSymbol = require_well_known_symbol(); |
| 512 |
var $TypeError = TypeError; |
| 513 |
var TO_PRIMITIVE = wellKnownSymbol("toPrimitive"); |
| 514 |
module.exports = function(input, pref) { |
| 515 |
if (!isObject(input) || isSymbol(input)) return input; |
| 516 |
var exoticToPrim = getMethod(input, TO_PRIMITIVE); |
| 517 |
var result; |
| 518 |
if (exoticToPrim) { |
| 519 |
if (pref === void 0) pref = "default"; |
| 520 |
result = call(exoticToPrim, input, pref); |
| 521 |
if (!isObject(result) || isSymbol(result)) return result; |
| 522 |
throw $TypeError("Can't convert object to primitive value"); |
| 523 |
} |
| 524 |
if (pref === void 0) pref = "number"; |
| 525 |
return ordinaryToPrimitive(input, pref); |
| 526 |
}; |
| 527 |
} |
| 528 |
}); |
| 529 |
|
| 530 |
// node_modules/core-js-pure/internals/to-property-key.js |
| 531 |
var require_to_property_key = __commonJS({ |
| 532 |
"node_modules/core-js-pure/internals/to-property-key.js"(exports, module) { |
| 533 |
var toPrimitive = require_to_primitive(); |
| 534 |
var isSymbol = require_is_symbol(); |
| 535 |
module.exports = function(argument) { |
| 536 |
var key = toPrimitive(argument, "string"); |
| 537 |
return isSymbol(key) ? key : key + ""; |
| 538 |
}; |
| 539 |
} |
| 540 |
}); |
| 541 |
|
| 542 |
// node_modules/core-js-pure/internals/document-create-element.js |
| 543 |
var require_document_create_element = __commonJS({ |
| 544 |
"node_modules/core-js-pure/internals/document-create-element.js"(exports, module) { |
| 545 |
var global2 = require_global(); |
| 546 |
var isObject = require_is_object(); |
| 547 |
var document2 = global2.document; |
| 548 |
var EXISTS = isObject(document2) && isObject(document2.createElement); |
| 549 |
module.exports = function(it) { |
| 550 |
return EXISTS ? document2.createElement(it) : {}; |
| 551 |
}; |
| 552 |
} |
| 553 |
}); |
| 554 |
|
| 555 |
// node_modules/core-js-pure/internals/ie8-dom-define.js |
| 556 |
var require_ie8_dom_define = __commonJS({ |
| 557 |
"node_modules/core-js-pure/internals/ie8-dom-define.js"(exports, module) { |
| 558 |
var DESCRIPTORS = require_descriptors(); |
| 559 |
var fails = require_fails(); |
| 560 |
var createElement = require_document_create_element(); |
| 561 |
module.exports = !DESCRIPTORS && !fails(function() { |
| 562 |
return Object.defineProperty(createElement("div"), "a", { |
| 563 |
get: function() { |
| 564 |
return 7; |
| 565 |
} |
| 566 |
}).a != 7; |
| 567 |
}); |
| 568 |
} |
| 569 |
}); |
| 570 |
|
| 571 |
// node_modules/core-js-pure/internals/object-get-own-property-descriptor.js |
| 572 |
var require_object_get_own_property_descriptor = __commonJS({ |
| 573 |
"node_modules/core-js-pure/internals/object-get-own-property-descriptor.js"(exports) { |
| 574 |
var DESCRIPTORS = require_descriptors(); |
| 575 |
var call = require_function_call(); |
| 576 |
var propertyIsEnumerableModule = require_object_property_is_enumerable(); |
| 577 |
var createPropertyDescriptor = require_create_property_descriptor(); |
| 578 |
var toIndexedObject = require_to_indexed_object(); |
| 579 |
var toPropertyKey = require_to_property_key(); |
| 580 |
var hasOwn = require_has_own_property(); |
| 581 |
var IE8_DOM_DEFINE = require_ie8_dom_define(); |
| 582 |
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; |
| 583 |
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { |
| 584 |
O = toIndexedObject(O); |
| 585 |
P = toPropertyKey(P); |
| 586 |
if (IE8_DOM_DEFINE) try { |
| 587 |
return $getOwnPropertyDescriptor(O, P); |
| 588 |
} catch (error) { |
| 589 |
} |
| 590 |
if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]); |
| 591 |
}; |
| 592 |
} |
| 593 |
}); |
| 594 |
|
| 595 |
// node_modules/core-js-pure/internals/is-forced.js |
| 596 |
var require_is_forced = __commonJS({ |
| 597 |
"node_modules/core-js-pure/internals/is-forced.js"(exports, module) { |
| 598 |
var fails = require_fails(); |
| 599 |
var isCallable = require_is_callable(); |
| 600 |
var replacement = /#|\.prototype\./; |
| 601 |
var isForced = function(feature, detection) { |
| 602 |
var value = data[normalize(feature)]; |
| 603 |
return value == POLYFILL ? true : value == NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection; |
| 604 |
}; |
| 605 |
var normalize = isForced.normalize = function(string) { |
| 606 |
return String(string).replace(replacement, ".").toLowerCase(); |
| 607 |
}; |
| 608 |
var data = isForced.data = {}; |
| 609 |
var NATIVE = isForced.NATIVE = "N"; |
| 610 |
var POLYFILL = isForced.POLYFILL = "P"; |
| 611 |
module.exports = isForced; |
| 612 |
} |
| 613 |
}); |
| 614 |
|
| 615 |
// node_modules/core-js-pure/internals/function-bind-context.js |
| 616 |
var require_function_bind_context = __commonJS({ |
| 617 |
"node_modules/core-js-pure/internals/function-bind-context.js"(exports, module) { |
| 618 |
var uncurryThis = require_function_uncurry_this_clause(); |
| 619 |
var aCallable = require_a_callable(); |
| 620 |
var NATIVE_BIND = require_function_bind_native(); |
| 621 |
var bind = uncurryThis(uncurryThis.bind); |
| 622 |
module.exports = function(fn, that) { |
| 623 |
aCallable(fn); |
| 624 |
return that === void 0 ? fn : NATIVE_BIND ? bind(fn, that) : function() { |
| 625 |
return fn.apply(that, arguments); |
| 626 |
}; |
| 627 |
}; |
| 628 |
} |
| 629 |
}); |
| 630 |
|
| 631 |
// node_modules/core-js-pure/internals/v8-prototype-define-bug.js |
| 632 |
var require_v8_prototype_define_bug = __commonJS({ |
| 633 |
"node_modules/core-js-pure/internals/v8-prototype-define-bug.js"(exports, module) { |
| 634 |
var DESCRIPTORS = require_descriptors(); |
| 635 |
var fails = require_fails(); |
| 636 |
module.exports = DESCRIPTORS && fails(function() { |
| 637 |
return Object.defineProperty(function() { |
| 638 |
}, "prototype", { |
| 639 |
value: 42, |
| 640 |
writable: false |
| 641 |
}).prototype != 42; |
| 642 |
}); |
| 643 |
} |
| 644 |
}); |
| 645 |
|
| 646 |
// node_modules/core-js-pure/internals/an-object.js |
| 647 |
var require_an_object = __commonJS({ |
| 648 |
"node_modules/core-js-pure/internals/an-object.js"(exports, module) { |
| 649 |
var isObject = require_is_object(); |
| 650 |
var $String = String; |
| 651 |
var $TypeError = TypeError; |
| 652 |
module.exports = function(argument) { |
| 653 |
if (isObject(argument)) return argument; |
| 654 |
throw $TypeError($String(argument) + " is not an object"); |
| 655 |
}; |
| 656 |
} |
| 657 |
}); |
| 658 |
|
| 659 |
// node_modules/core-js-pure/internals/object-define-property.js |
| 660 |
var require_object_define_property = __commonJS({ |
| 661 |
"node_modules/core-js-pure/internals/object-define-property.js"(exports) { |
| 662 |
var DESCRIPTORS = require_descriptors(); |
| 663 |
var IE8_DOM_DEFINE = require_ie8_dom_define(); |
| 664 |
var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug(); |
| 665 |
var anObject = require_an_object(); |
| 666 |
var toPropertyKey = require_to_property_key(); |
| 667 |
var $TypeError = TypeError; |
| 668 |
var $defineProperty = Object.defineProperty; |
| 669 |
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; |
| 670 |
var ENUMERABLE = "enumerable"; |
| 671 |
var CONFIGURABLE = "configurable"; |
| 672 |
var WRITABLE = "writable"; |
| 673 |
exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) { |
| 674 |
anObject(O); |
| 675 |
P = toPropertyKey(P); |
| 676 |
anObject(Attributes); |
| 677 |
if (typeof O === "function" && P === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { |
| 678 |
var current = $getOwnPropertyDescriptor(O, P); |
| 679 |
if (current && current[WRITABLE]) { |
| 680 |
O[P] = Attributes.value; |
| 681 |
Attributes = { |
| 682 |
configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], |
| 683 |
enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], |
| 684 |
writable: false |
| 685 |
}; |
| 686 |
} |
| 687 |
} |
| 688 |
return $defineProperty(O, P, Attributes); |
| 689 |
} : $defineProperty : function defineProperty(O, P, Attributes) { |
| 690 |
anObject(O); |
| 691 |
P = toPropertyKey(P); |
| 692 |
anObject(Attributes); |
| 693 |
if (IE8_DOM_DEFINE) try { |
| 694 |
return $defineProperty(O, P, Attributes); |
| 695 |
} catch (error) { |
| 696 |
} |
| 697 |
if ("get" in Attributes || "set" in Attributes) throw $TypeError("Accessors not supported"); |
| 698 |
if ("value" in Attributes) O[P] = Attributes.value; |
| 699 |
return O; |
| 700 |
}; |
| 701 |
} |
| 702 |
}); |
| 703 |
|
| 704 |
// node_modules/core-js-pure/internals/create-non-enumerable-property.js |
| 705 |
var require_create_non_enumerable_property = __commonJS({ |
| 706 |
"node_modules/core-js-pure/internals/create-non-enumerable-property.js"(exports, module) { |
| 707 |
var DESCRIPTORS = require_descriptors(); |
| 708 |
var definePropertyModule = require_object_define_property(); |
| 709 |
var createPropertyDescriptor = require_create_property_descriptor(); |
| 710 |
module.exports = DESCRIPTORS ? function(object, key, value) { |
| 711 |
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); |
| 712 |
} : function(object, key, value) { |
| 713 |
object[key] = value; |
| 714 |
return object; |
| 715 |
}; |
| 716 |
} |
| 717 |
}); |
| 718 |
|
| 719 |
// node_modules/core-js-pure/internals/export.js |
| 720 |
var require_export = __commonJS({ |
| 721 |
"node_modules/core-js-pure/internals/export.js"(exports, module) { |
| 722 |
"use strict"; |
| 723 |
var global2 = require_global(); |
| 724 |
var apply = require_function_apply(); |
| 725 |
var uncurryThis = require_function_uncurry_this_clause(); |
| 726 |
var isCallable = require_is_callable(); |
| 727 |
var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f; |
| 728 |
var isForced = require_is_forced(); |
| 729 |
var path = require_path(); |
| 730 |
var bind = require_function_bind_context(); |
| 731 |
var createNonEnumerableProperty = require_create_non_enumerable_property(); |
| 732 |
var hasOwn = require_has_own_property(); |
| 733 |
var wrapConstructor = function(NativeConstructor) { |
| 734 |
var Wrapper = function(a, b, c) { |
| 735 |
if (this instanceof Wrapper) { |
| 736 |
switch (arguments.length) { |
| 737 |
case 0: |
| 738 |
return new NativeConstructor(); |
| 739 |
case 1: |
| 740 |
return new NativeConstructor(a); |
| 741 |
case 2: |
| 742 |
return new NativeConstructor(a, b); |
| 743 |
} |
| 744 |
return new NativeConstructor(a, b, c); |
| 745 |
} |
| 746 |
return apply(NativeConstructor, this, arguments); |
| 747 |
}; |
| 748 |
Wrapper.prototype = NativeConstructor.prototype; |
| 749 |
return Wrapper; |
| 750 |
}; |
| 751 |
module.exports = function(options, source) { |
| 752 |
var TARGET = options.target; |
| 753 |
var GLOBAL = options.global; |
| 754 |
var STATIC = options.stat; |
| 755 |
var PROTO = options.proto; |
| 756 |
var nativeSource = GLOBAL ? global2 : STATIC ? global2[TARGET] : (global2[TARGET] || {}).prototype; |
| 757 |
var target = GLOBAL ? path : path[TARGET] || createNonEnumerableProperty(path, TARGET, {})[TARGET]; |
| 758 |
var targetPrototype = target.prototype; |
| 759 |
var FORCED, USE_NATIVE, VIRTUAL_PROTOTYPE; |
| 760 |
var key, sourceProperty, targetProperty, nativeProperty, resultProperty, descriptor; |
| 761 |
for (key in source) { |
| 762 |
FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced); |
| 763 |
USE_NATIVE = !FORCED && nativeSource && hasOwn(nativeSource, key); |
| 764 |
targetProperty = target[key]; |
| 765 |
if (USE_NATIVE) if (options.dontCallGetSet) { |
| 766 |
descriptor = getOwnPropertyDescriptor(nativeSource, key); |
| 767 |
nativeProperty = descriptor && descriptor.value; |
| 768 |
} else nativeProperty = nativeSource[key]; |
| 769 |
sourceProperty = USE_NATIVE && nativeProperty ? nativeProperty : source[key]; |
| 770 |
if (USE_NATIVE && typeof targetProperty == typeof sourceProperty) continue; |
| 771 |
if (options.bind && USE_NATIVE) resultProperty = bind(sourceProperty, global2); |
| 772 |
else if (options.wrap && USE_NATIVE) resultProperty = wrapConstructor(sourceProperty); |
| 773 |
else if (PROTO && isCallable(sourceProperty)) resultProperty = uncurryThis(sourceProperty); |
| 774 |
else resultProperty = sourceProperty; |
| 775 |
if (options.sham || sourceProperty && sourceProperty.sham || targetProperty && targetProperty.sham) { |
| 776 |
createNonEnumerableProperty(resultProperty, "sham", true); |
| 777 |
} |
| 778 |
createNonEnumerableProperty(target, key, resultProperty); |
| 779 |
if (PROTO) { |
| 780 |
VIRTUAL_PROTOTYPE = TARGET + "Prototype"; |
| 781 |
if (!hasOwn(path, VIRTUAL_PROTOTYPE)) { |
| 782 |
createNonEnumerableProperty(path, VIRTUAL_PROTOTYPE, {}); |
| 783 |
} |
| 784 |
createNonEnumerableProperty(path[VIRTUAL_PROTOTYPE], key, sourceProperty); |
| 785 |
if (options.real && targetPrototype && (FORCED || !targetPrototype[key])) { |
| 786 |
createNonEnumerableProperty(targetPrototype, key, sourceProperty); |
| 787 |
} |
| 788 |
} |
| 789 |
} |
| 790 |
}; |
| 791 |
} |
| 792 |
}); |
| 793 |
|
| 794 |
// node_modules/core-js-pure/modules/es.global-this.js |
| 795 |
var require_es_global_this = __commonJS({ |
| 796 |
"node_modules/core-js-pure/modules/es.global-this.js"() { |
| 797 |
var $ = require_export(); |
| 798 |
var global2 = require_global(); |
| 799 |
$({ global: true, forced: global2.globalThis !== global2 }, { |
| 800 |
globalThis: global2 |
| 801 |
}); |
| 802 |
} |
| 803 |
}); |
| 804 |
|
| 805 |
// node_modules/core-js-pure/modules/esnext.global-this.js |
| 806 |
var require_esnext_global_this = __commonJS({ |
| 807 |
"node_modules/core-js-pure/modules/esnext.global-this.js"() { |
| 808 |
require_es_global_this(); |
| 809 |
} |
| 810 |
}); |
| 811 |
|
| 812 |
// node_modules/core-js-pure/es/global-this.js |
| 813 |
var require_global_this = __commonJS({ |
| 814 |
"node_modules/core-js-pure/es/global-this.js"(exports, module) { |
| 815 |
require_es_global_this(); |
| 816 |
module.exports = require_global(); |
| 817 |
} |
| 818 |
}); |
| 819 |
|
| 820 |
// node_modules/core-js-pure/stable/global-this.js |
| 821 |
var require_global_this2 = __commonJS({ |
| 822 |
"node_modules/core-js-pure/stable/global-this.js"(exports, module) { |
| 823 |
var parent = require_global_this(); |
| 824 |
module.exports = parent; |
| 825 |
} |
| 826 |
}); |
| 827 |
|
| 828 |
// node_modules/core-js-pure/actual/global-this.js |
| 829 |
var require_global_this3 = __commonJS({ |
| 830 |
"node_modules/core-js-pure/actual/global-this.js"(exports, module) { |
| 831 |
var parent = require_global_this2(); |
| 832 |
module.exports = parent; |
| 833 |
} |
| 834 |
}); |
| 835 |
|
| 836 |
// node_modules/core-js-pure/full/global-this.js |
| 837 |
var require_global_this4 = __commonJS({ |
| 838 |
"node_modules/core-js-pure/full/global-this.js"(exports, module) { |
| 839 |
require_esnext_global_this(); |
| 840 |
var parent = require_global_this3(); |
| 841 |
module.exports = parent; |
| 842 |
} |
| 843 |
}); |
| 844 |
|
| 845 |
// node_modules/core-js-pure/features/global-this.js |
| 846 |
var require_global_this5 = __commonJS({ |
| 847 |
"node_modules/core-js-pure/features/global-this.js"(exports, module) { |
| 848 |
module.exports = require_global_this4(); |
| 849 |
} |
| 850 |
}); |
| 851 |
|
| 852 |
// node_modules/react-refresh/cjs/react-refresh-runtime.development.js |
| 853 |
var require_react_refresh_runtime_development = __commonJS({ |
| 854 |
"node_modules/react-refresh/cjs/react-refresh-runtime.development.js"(exports) { |
| 855 |
"use strict"; |
| 856 |
if (true) { |
| 857 |
(function() { |
| 858 |
"use strict"; |
| 859 |
var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"); |
| 860 |
var REACT_MEMO_TYPE = Symbol.for("react.memo"); |
| 861 |
var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map; |
| 862 |
var allFamiliesByID = /* @__PURE__ */ new Map(); |
| 863 |
var allFamiliesByType = new PossiblyWeakMap(); |
| 864 |
var allSignaturesByType = new PossiblyWeakMap(); |
| 865 |
var updatedFamiliesByType = new PossiblyWeakMap(); |
| 866 |
var pendingUpdates = []; |
| 867 |
var helpersByRendererID = /* @__PURE__ */ new Map(); |
| 868 |
var helpersByRoot = /* @__PURE__ */ new Map(); |
| 869 |
var mountedRoots = /* @__PURE__ */ new Set(); |
| 870 |
var failedRoots = /* @__PURE__ */ new Set(); |
| 871 |
var rootElements = ( |
| 872 |
// $FlowIssue |
| 873 |
typeof WeakMap === "function" ? /* @__PURE__ */ new WeakMap() : null |
| 874 |
); |
| 875 |
var isPerformingRefresh = false; |
| 876 |
function computeFullKey(signature) { |
| 877 |
if (signature.fullKey !== null) { |
| 878 |
return signature.fullKey; |
| 879 |
} |
| 880 |
var fullKey = signature.ownKey; |
| 881 |
var hooks; |
| 882 |
try { |
| 883 |
hooks = signature.getCustomHooks(); |
| 884 |
} catch (err) { |
| 885 |
signature.forceReset = true; |
| 886 |
signature.fullKey = fullKey; |
| 887 |
return fullKey; |
| 888 |
} |
| 889 |
for (var i = 0; i < hooks.length; i++) { |
| 890 |
var hook = hooks[i]; |
| 891 |
if (typeof hook !== "function") { |
| 892 |
signature.forceReset = true; |
| 893 |
signature.fullKey = fullKey; |
| 894 |
return fullKey; |
| 895 |
} |
| 896 |
var nestedHookSignature = allSignaturesByType.get(hook); |
| 897 |
if (nestedHookSignature === void 0) { |
| 898 |
continue; |
| 899 |
} |
| 900 |
var nestedHookKey = computeFullKey(nestedHookSignature); |
| 901 |
if (nestedHookSignature.forceReset) { |
| 902 |
signature.forceReset = true; |
| 903 |
} |
| 904 |
fullKey += "\n---\n" + nestedHookKey; |
| 905 |
} |
| 906 |
signature.fullKey = fullKey; |
| 907 |
return fullKey; |
| 908 |
} |
| 909 |
function haveEqualSignatures(prevType, nextType) { |
| 910 |
var prevSignature = allSignaturesByType.get(prevType); |
| 911 |
var nextSignature = allSignaturesByType.get(nextType); |
| 912 |
if (prevSignature === void 0 && nextSignature === void 0) { |
| 913 |
return true; |
| 914 |
} |
| 915 |
if (prevSignature === void 0 || nextSignature === void 0) { |
| 916 |
return false; |
| 917 |
} |
| 918 |
if (computeFullKey(prevSignature) !== computeFullKey(nextSignature)) { |
| 919 |
return false; |
| 920 |
} |
| 921 |
if (nextSignature.forceReset) { |
| 922 |
return false; |
| 923 |
} |
| 924 |
return true; |
| 925 |
} |
| 926 |
function isReactClass(type) { |
| 927 |
return type.prototype && type.prototype.isReactComponent; |
| 928 |
} |
| 929 |
function canPreserveStateBetween(prevType, nextType) { |
| 930 |
if (isReactClass(prevType) || isReactClass(nextType)) { |
| 931 |
return false; |
| 932 |
} |
| 933 |
if (haveEqualSignatures(prevType, nextType)) { |
| 934 |
return true; |
| 935 |
} |
| 936 |
return false; |
| 937 |
} |
| 938 |
function resolveFamily(type) { |
| 939 |
return updatedFamiliesByType.get(type); |
| 940 |
} |
| 941 |
function cloneMap(map) { |
| 942 |
var clone = /* @__PURE__ */ new Map(); |
| 943 |
map.forEach(function(value, key) { |
| 944 |
clone.set(key, value); |
| 945 |
}); |
| 946 |
return clone; |
| 947 |
} |
| 948 |
function cloneSet(set) { |
| 949 |
var clone = /* @__PURE__ */ new Set(); |
| 950 |
set.forEach(function(value) { |
| 951 |
clone.add(value); |
| 952 |
}); |
| 953 |
return clone; |
| 954 |
} |
| 955 |
function getProperty(object, property) { |
| 956 |
try { |
| 957 |
return object[property]; |
| 958 |
} catch (err) { |
| 959 |
return void 0; |
| 960 |
} |
| 961 |
} |
| 962 |
function performReactRefresh() { |
| 963 |
if (pendingUpdates.length === 0) { |
| 964 |
return null; |
| 965 |
} |
| 966 |
if (isPerformingRefresh) { |
| 967 |
return null; |
| 968 |
} |
| 969 |
isPerformingRefresh = true; |
| 970 |
try { |
| 971 |
var staleFamilies = /* @__PURE__ */ new Set(); |
| 972 |
var updatedFamilies = /* @__PURE__ */ new Set(); |
| 973 |
var updates = pendingUpdates; |
| 974 |
pendingUpdates = []; |
| 975 |
updates.forEach(function(_ref) { |
| 976 |
var family = _ref[0], nextType = _ref[1]; |
| 977 |
var prevType = family.current; |
| 978 |
updatedFamiliesByType.set(prevType, family); |
| 979 |
updatedFamiliesByType.set(nextType, family); |
| 980 |
family.current = nextType; |
| 981 |
if (canPreserveStateBetween(prevType, nextType)) { |
| 982 |
updatedFamilies.add(family); |
| 983 |
} else { |
| 984 |
staleFamilies.add(family); |
| 985 |
} |
| 986 |
}); |
| 987 |
var update = { |
| 988 |
updatedFamilies, |
| 989 |
// Families that will re-render preserving state |
| 990 |
staleFamilies |
| 991 |
// Families that will be remounted |
| 992 |
}; |
| 993 |
helpersByRendererID.forEach(function(helpers) { |
| 994 |
helpers.setRefreshHandler(resolveFamily); |
| 995 |
}); |
| 996 |
var didError = false; |
| 997 |
var firstError = null; |
| 998 |
var failedRootsSnapshot = cloneSet(failedRoots); |
| 999 |
var mountedRootsSnapshot = cloneSet(mountedRoots); |
| 1000 |
var helpersByRootSnapshot = cloneMap(helpersByRoot); |
| 1001 |
failedRootsSnapshot.forEach(function(root) { |
| 1002 |
var helpers = helpersByRootSnapshot.get(root); |
| 1003 |
if (helpers === void 0) { |
| 1004 |
throw new Error("Could not find helpers for a root. This is a bug in React Refresh."); |
| 1005 |
} |
| 1006 |
if (!failedRoots.has(root)) { |
| 1007 |
} |
| 1008 |
if (rootElements === null) { |
| 1009 |
return; |
| 1010 |
} |
| 1011 |
if (!rootElements.has(root)) { |
| 1012 |
return; |
| 1013 |
} |
| 1014 |
var element = rootElements.get(root); |
| 1015 |
try { |
| 1016 |
helpers.scheduleRoot(root, element); |
| 1017 |
} catch (err) { |
| 1018 |
if (!didError) { |
| 1019 |
didError = true; |
| 1020 |
firstError = err; |
| 1021 |
} |
| 1022 |
} |
| 1023 |
}); |
| 1024 |
mountedRootsSnapshot.forEach(function(root) { |
| 1025 |
var helpers = helpersByRootSnapshot.get(root); |
| 1026 |
if (helpers === void 0) { |
| 1027 |
throw new Error("Could not find helpers for a root. This is a bug in React Refresh."); |
| 1028 |
} |
| 1029 |
if (!mountedRoots.has(root)) { |
| 1030 |
} |
| 1031 |
try { |
| 1032 |
helpers.scheduleRefresh(root, update); |
| 1033 |
} catch (err) { |
| 1034 |
if (!didError) { |
| 1035 |
didError = true; |
| 1036 |
firstError = err; |
| 1037 |
} |
| 1038 |
} |
| 1039 |
}); |
| 1040 |
if (didError) { |
| 1041 |
throw firstError; |
| 1042 |
} |
| 1043 |
return update; |
| 1044 |
} finally { |
| 1045 |
isPerformingRefresh = false; |
| 1046 |
} |
| 1047 |
} |
| 1048 |
function register(type, id) { |
| 1049 |
{ |
| 1050 |
if (type === null) { |
| 1051 |
return; |
| 1052 |
} |
| 1053 |
if (typeof type !== "function" && typeof type !== "object") { |
| 1054 |
return; |
| 1055 |
} |
| 1056 |
if (allFamiliesByType.has(type)) { |
| 1057 |
return; |
| 1058 |
} |
| 1059 |
var family = allFamiliesByID.get(id); |
| 1060 |
if (family === void 0) { |
| 1061 |
family = { |
| 1062 |
current: type |
| 1063 |
}; |
| 1064 |
allFamiliesByID.set(id, family); |
| 1065 |
} else { |
| 1066 |
pendingUpdates.push([family, type]); |
| 1067 |
} |
| 1068 |
allFamiliesByType.set(type, family); |
| 1069 |
if (typeof type === "object" && type !== null) { |
| 1070 |
switch (getProperty(type, "$$typeof")) { |
| 1071 |
case REACT_FORWARD_REF_TYPE: |
| 1072 |
register(type.render, id + "$render"); |
| 1073 |
break; |
| 1074 |
case REACT_MEMO_TYPE: |
| 1075 |
register(type.type, id + "$type"); |
| 1076 |
break; |
| 1077 |
} |
| 1078 |
} |
| 1079 |
} |
| 1080 |
} |
| 1081 |
function setSignature(type, key) { |
| 1082 |
var forceReset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false; |
| 1083 |
var getCustomHooks = arguments.length > 3 ? arguments[3] : void 0; |
| 1084 |
{ |
| 1085 |
if (!allSignaturesByType.has(type)) { |
| 1086 |
allSignaturesByType.set(type, { |
| 1087 |
forceReset, |
| 1088 |
ownKey: key, |
| 1089 |
fullKey: null, |
| 1090 |
getCustomHooks: getCustomHooks || function() { |
| 1091 |
return []; |
| 1092 |
} |
| 1093 |
}); |
| 1094 |
} |
| 1095 |
if (typeof type === "object" && type !== null) { |
| 1096 |
switch (getProperty(type, "$$typeof")) { |
| 1097 |
case REACT_FORWARD_REF_TYPE: |
| 1098 |
setSignature(type.render, key, forceReset, getCustomHooks); |
| 1099 |
break; |
| 1100 |
case REACT_MEMO_TYPE: |
| 1101 |
setSignature(type.type, key, forceReset, getCustomHooks); |
| 1102 |
break; |
| 1103 |
} |
| 1104 |
} |
| 1105 |
} |
| 1106 |
} |
| 1107 |
function collectCustomHooksForSignature(type) { |
| 1108 |
{ |
| 1109 |
var signature = allSignaturesByType.get(type); |
| 1110 |
if (signature !== void 0) { |
| 1111 |
computeFullKey(signature); |
| 1112 |
} |
| 1113 |
} |
| 1114 |
} |
| 1115 |
function getFamilyByID(id) { |
| 1116 |
{ |
| 1117 |
return allFamiliesByID.get(id); |
| 1118 |
} |
| 1119 |
} |
| 1120 |
function getFamilyByType(type) { |
| 1121 |
{ |
| 1122 |
return allFamiliesByType.get(type); |
| 1123 |
} |
| 1124 |
} |
| 1125 |
function findAffectedHostInstances(families) { |
| 1126 |
{ |
| 1127 |
var affectedInstances = /* @__PURE__ */ new Set(); |
| 1128 |
mountedRoots.forEach(function(root) { |
| 1129 |
var helpers = helpersByRoot.get(root); |
| 1130 |
if (helpers === void 0) { |
| 1131 |
throw new Error("Could not find helpers for a root. This is a bug in React Refresh."); |
| 1132 |
} |
| 1133 |
var instancesForRoot = helpers.findHostInstancesForRefresh(root, families); |
| 1134 |
instancesForRoot.forEach(function(inst) { |
| 1135 |
affectedInstances.add(inst); |
| 1136 |
}); |
| 1137 |
}); |
| 1138 |
return affectedInstances; |
| 1139 |
} |
| 1140 |
} |
| 1141 |
function injectIntoGlobalHook(globalObject) { |
| 1142 |
{ |
| 1143 |
var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__; |
| 1144 |
if (hook === void 0) { |
| 1145 |
var nextID = 0; |
| 1146 |
globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = { |
| 1147 |
renderers: /* @__PURE__ */ new Map(), |
| 1148 |
supportsFiber: true, |
| 1149 |
inject: function(injected) { |
| 1150 |
return nextID++; |
| 1151 |
}, |
| 1152 |
onScheduleFiberRoot: function(id, root, children) { |
| 1153 |
}, |
| 1154 |
onCommitFiberRoot: function(id, root, maybePriorityLevel, didError) { |
| 1155 |
}, |
| 1156 |
onCommitFiberUnmount: function() { |
| 1157 |
} |
| 1158 |
}; |
| 1159 |
} |
| 1160 |
if (hook.isDisabled) { |
| 1161 |
console["warn"]("Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled."); |
| 1162 |
return; |
| 1163 |
} |
| 1164 |
var oldInject = hook.inject; |
| 1165 |
hook.inject = function(injected) { |
| 1166 |
var id = oldInject.apply(this, arguments); |
| 1167 |
if (typeof injected.scheduleRefresh === "function" && typeof injected.setRefreshHandler === "function") { |
| 1168 |
helpersByRendererID.set(id, injected); |
| 1169 |
} |
| 1170 |
return id; |
| 1171 |
}; |
| 1172 |
hook.renderers.forEach(function(injected, id) { |
| 1173 |
if (typeof injected.scheduleRefresh === "function" && typeof injected.setRefreshHandler === "function") { |
| 1174 |
helpersByRendererID.set(id, injected); |
| 1175 |
} |
| 1176 |
}); |
| 1177 |
var oldOnCommitFiberRoot = hook.onCommitFiberRoot; |
| 1178 |
var oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function() { |
| 1179 |
}; |
| 1180 |
hook.onScheduleFiberRoot = function(id, root, children) { |
| 1181 |
if (!isPerformingRefresh) { |
| 1182 |
failedRoots.delete(root); |
| 1183 |
if (rootElements !== null) { |
| 1184 |
rootElements.set(root, children); |
| 1185 |
} |
| 1186 |
} |
| 1187 |
return oldOnScheduleFiberRoot.apply(this, arguments); |
| 1188 |
}; |
| 1189 |
hook.onCommitFiberRoot = function(id, root, maybePriorityLevel, didError) { |
| 1190 |
var helpers = helpersByRendererID.get(id); |
| 1191 |
if (helpers !== void 0) { |
| 1192 |
helpersByRoot.set(root, helpers); |
| 1193 |
var current = root.current; |
| 1194 |
var alternate = current.alternate; |
| 1195 |
if (alternate !== null) { |
| 1196 |
var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null && mountedRoots.has(root); |
| 1197 |
var isMounted = current.memoizedState != null && current.memoizedState.element != null; |
| 1198 |
if (!wasMounted && isMounted) { |
| 1199 |
mountedRoots.add(root); |
| 1200 |
failedRoots.delete(root); |
| 1201 |
} else if (wasMounted && isMounted) ; |
| 1202 |
else if (wasMounted && !isMounted) { |
| 1203 |
mountedRoots.delete(root); |
| 1204 |
if (didError) { |
| 1205 |
failedRoots.add(root); |
| 1206 |
} else { |
| 1207 |
helpersByRoot.delete(root); |
| 1208 |
} |
| 1209 |
} else if (!wasMounted && !isMounted) { |
| 1210 |
if (didError) { |
| 1211 |
failedRoots.add(root); |
| 1212 |
} |
| 1213 |
} |
| 1214 |
} else { |
| 1215 |
mountedRoots.add(root); |
| 1216 |
} |
| 1217 |
} |
| 1218 |
return oldOnCommitFiberRoot.apply(this, arguments); |
| 1219 |
}; |
| 1220 |
} |
| 1221 |
} |
| 1222 |
function hasUnrecoverableErrors() { |
| 1223 |
return false; |
| 1224 |
} |
| 1225 |
function _getMountedRootCount() { |
| 1226 |
{ |
| 1227 |
return mountedRoots.size; |
| 1228 |
} |
| 1229 |
} |
| 1230 |
function createSignatureFunctionForTransform() { |
| 1231 |
{ |
| 1232 |
var savedType; |
| 1233 |
var hasCustomHooks; |
| 1234 |
var didCollectHooks = false; |
| 1235 |
return function(type, key, forceReset, getCustomHooks) { |
| 1236 |
if (typeof key === "string") { |
| 1237 |
if (!savedType) { |
| 1238 |
savedType = type; |
| 1239 |
hasCustomHooks = typeof getCustomHooks === "function"; |
| 1240 |
} |
| 1241 |
if (type != null && (typeof type === "function" || typeof type === "object")) { |
| 1242 |
setSignature(type, key, forceReset, getCustomHooks); |
| 1243 |
} |
| 1244 |
return type; |
| 1245 |
} else { |
| 1246 |
if (!didCollectHooks && hasCustomHooks) { |
| 1247 |
didCollectHooks = true; |
| 1248 |
collectCustomHooksForSignature(savedType); |
| 1249 |
} |
| 1250 |
} |
| 1251 |
}; |
| 1252 |
} |
| 1253 |
} |
| 1254 |
function isLikelyComponentType(type) { |
| 1255 |
{ |
| 1256 |
switch (typeof type) { |
| 1257 |
case "function": { |
| 1258 |
if (type.prototype != null) { |
| 1259 |
if (type.prototype.isReactComponent) { |
| 1260 |
return true; |
| 1261 |
} |
| 1262 |
var ownNames = Object.getOwnPropertyNames(type.prototype); |
| 1263 |
if (ownNames.length > 1 || ownNames[0] !== "constructor") { |
| 1264 |
return false; |
| 1265 |
} |
| 1266 |
if (type.prototype.__proto__ !== Object.prototype) { |
| 1267 |
return false; |
| 1268 |
} |
| 1269 |
} |
| 1270 |
var name = type.name || type.displayName; |
| 1271 |
return typeof name === "string" && /^[A-Z]/.test(name); |
| 1272 |
} |
| 1273 |
case "object": { |
| 1274 |
if (type != null) { |
| 1275 |
switch (getProperty(type, "$$typeof")) { |
| 1276 |
case REACT_FORWARD_REF_TYPE: |
| 1277 |
case REACT_MEMO_TYPE: |
| 1278 |
return true; |
| 1279 |
default: |
| 1280 |
return false; |
| 1281 |
} |
| 1282 |
} |
| 1283 |
return false; |
| 1284 |
} |
| 1285 |
default: { |
| 1286 |
return false; |
| 1287 |
} |
| 1288 |
} |
| 1289 |
} |
| 1290 |
} |
| 1291 |
exports._getMountedRootCount = _getMountedRootCount; |
| 1292 |
exports.collectCustomHooksForSignature = collectCustomHooksForSignature; |
| 1293 |
exports.createSignatureFunctionForTransform = createSignatureFunctionForTransform; |
| 1294 |
exports.findAffectedHostInstances = findAffectedHostInstances; |
| 1295 |
exports.getFamilyByID = getFamilyByID; |
| 1296 |
exports.getFamilyByType = getFamilyByType; |
| 1297 |
exports.hasUnrecoverableErrors = hasUnrecoverableErrors; |
| 1298 |
exports.injectIntoGlobalHook = injectIntoGlobalHook; |
| 1299 |
exports.isLikelyComponentType = isLikelyComponentType; |
| 1300 |
exports.performReactRefresh = performReactRefresh; |
| 1301 |
exports.register = register; |
| 1302 |
exports.setSignature = setSignature; |
| 1303 |
})(); |
| 1304 |
} |
| 1305 |
} |
| 1306 |
}); |
| 1307 |
|
| 1308 |
// node_modules/react-refresh/runtime.js |
| 1309 |
var require_runtime = __commonJS({ |
| 1310 |
"node_modules/react-refresh/runtime.js"(exports, module) { |
| 1311 |
"use strict"; |
| 1312 |
if (false) { |
| 1313 |
module.exports = null; |
| 1314 |
} else { |
| 1315 |
module.exports = require_react_refresh_runtime_development(); |
| 1316 |
} |
| 1317 |
} |
| 1318 |
}); |
| 1319 |
|
| 1320 |
// node_modules/@pmmmwh/react-refresh-webpack-plugin/client/ReactRefreshEntry.js |
| 1321 |
var require_ReactRefreshEntry = __commonJS({ |
| 1322 |
"node_modules/@pmmmwh/react-refresh-webpack-plugin/client/ReactRefreshEntry.js"() { |
| 1323 |
var safeThis = require_global_this5(); |
| 1324 |
var RefreshRuntime = require_runtime(); |
| 1325 |
if (true) { |
| 1326 |
if (typeof safeThis !== "undefined") { |
| 1327 |
$RefreshInjected$ = "__reactRefreshInjected"; |
| 1328 |
if (typeof __react_refresh_library__ !== "undefined" && __react_refresh_library__) { |
| 1329 |
$RefreshInjected$ += "_" + __react_refresh_library__; |
| 1330 |
} |
| 1331 |
if (!safeThis[$RefreshInjected$]) { |
| 1332 |
RefreshRuntime.injectIntoGlobalHook(safeThis); |
| 1333 |
safeThis[$RefreshInjected$] = true; |
| 1334 |
} |
| 1335 |
} |
| 1336 |
} |
| 1337 |
var $RefreshInjected$; |
| 1338 |
} |
| 1339 |
}); |
| 1340 |
require_ReactRefreshEntry(); |
| 1341 |
})(); |
| 1342 |
/*! Bundled license information: |
| 1343 |
|
| 1344 |
react-refresh/cjs/react-refresh-runtime.development.js: |
| 1345 |
(** |
| 1346 |
* @license React |
| 1347 |
* react-refresh-runtime.development.js |
| 1348 |
* |
| 1349 |
* Copyright (c) Facebook, Inc. and its affiliates. |
| 1350 |
* |
| 1351 |
* This source code is licensed under the MIT license found in the |
| 1352 |
* LICENSE file in the root directory of this source tree. |
| 1353 |
*) |
| 1354 |
*/ |
| 1355 |
|
