1(self["webpackChunk"] = self["webpackChunk"] || []).push([["/js/vendor"],{ 2
vendor: 181,713 bytes, lines 3-5944
3/***/ "./node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js": 4/*!***************************************************************************!*\ 5 !*** ./node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js ***! 6 \***************************************************************************/ 7/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 8 9"use strict"; 10__webpack_require__.r(__webpack_exports__); 11/* harmony export */ __webpack_require__.d(__webpack_exports__, { 12/* harmony export */ BASE_TRANSITION: () => (/* binding */ BASE_TRANSITION), 13/* harmony export */ BindingTypes: () => (/* binding */ BindingTypes), 14/* harmony export */ CAMELIZE: () => (/* binding */ CAMELIZE), 15/* harmony export */ CAPITALIZE: () => (/* binding */ CAPITALIZE), 16/* harmony export */ CREATE_BLOCK: () => (/* binding */ CREATE_BLOCK), 17/* harmony export */ CREATE_COMMENT: () => (/* binding */ CREATE_COMMENT), 18/* harmony export */ CREATE_ELEMENT_BLOCK: () => (/* binding */ CREATE_ELEMENT_BLOCK), 19/* harmony export */ CREATE_ELEMENT_VNODE: () => (/* binding */ CREATE_ELEMENT_VNODE), 20/* harmony export */ CREATE_SLOTS: () => (/* binding */ CREATE_SLOTS), 21/* harmony export */ CREATE_STATIC: () => (/* binding */ CREATE_STATIC), 22/* harmony export */ CREATE_TEXT: () => (/* binding */ CREATE_TEXT), 23/* harmony export */ CREATE_VNODE: () => (/* binding */ CREATE_VNODE), 24/* harmony export */ CompilerDeprecationTypes: () => (/* binding */ CompilerDeprecationTypes), 25/* harmony export */ ConstantTypes: () => (/* binding */ ConstantTypes), 26/* harmony export */ ElementTypes: () => (/* binding */ ElementTypes), 27/* harmony export */ ErrorCodes: () => (/* binding */ ErrorCodes), 28/* harmony export */ FRAGMENT: () => (/* binding */ FRAGMENT), 29/* harmony export */ GUARD_REACTIVE_PROPS: () => (/* binding */ GUARD_REACTIVE_PROPS), 30/* harmony export */ IS_MEMO_SAME: () => (/* binding */ IS_MEMO_SAME), 31/* harmony export */ IS_REF: () => (/* binding */ IS_REF), 32/* harmony export */ KEEP_ALIVE: () => (/* binding */ KEEP_ALIVE), 33/* harmony export */ MERGE_PROPS: () => (/* binding */ MERGE_PROPS), 34/* harmony export */ NORMALIZE_CLASS: () => (/* binding */ NORMALIZE_CLASS), 35/* harmony export */ NORMALIZE_PROPS: () => (/* binding */ NORMALIZE_PROPS), 36/* harmony export */ NORMALIZE_STYLE: () => (/* binding */ NORMALIZE_STYLE), 37/* harmony export */ Namespaces: () => (/* binding */ Namespaces), 38/* harmony export */ NodeTypes: () => (/* binding */ NodeTypes), 39/* harmony export */ OPEN_BLOCK: () => (/* binding */ OPEN_BLOCK), 40/* harmony export */ POP_SCOPE_ID: () => (/* binding */ POP_SCOPE_ID), 41/* harmony export */ PUSH_SCOPE_ID: () => (/* binding */ PUSH_SCOPE_ID), 42/* harmony export */ RENDER_LIST: () => (/* binding */ RENDER_LIST), 43/* harmony export */ RENDER_SLOT: () => (/* binding */ RENDER_SLOT), 44/* harmony export */ RESOLVE_COMPONENT: () => (/* binding */ RESOLVE_COMPONENT), 45/* harmony export */ RESOLVE_DIRECTIVE: () => (/* binding */ RESOLVE_DIRECTIVE), 46/* harmony export */ RESOLVE_DYNAMIC_COMPONENT: () => (/* binding */ RESOLVE_DYNAMIC_COMPONENT), 47/* harmony export */ RESOLVE_FILTER: () => (/* binding */ RESOLVE_FILTER), 48/* harmony export */ SET_BLOCK_TRACKING: () => (/* binding */ SET_BLOCK_TRACKING), 49/* harmony export */ SUSPENSE: () => (/* binding */ SUSPENSE), 50/* harmony export */ TELEPORT: () => (/* binding */ TELEPORT), 51/* harmony export */ TO_DISPLAY_STRING: () => (/* binding */ TO_DISPLAY_STRING), 52/* harmony export */ TO_HANDLERS: () => (/* binding */ TO_HANDLERS), 53/* harmony export */ TO_HANDLER_KEY: () => (/* binding */ TO_HANDLER_KEY), 54/* harmony export */ TS_NODE_TYPES: () => (/* binding */ TS_NODE_TYPES), 55/* harmony export */ UNREF: () => (/* binding */ UNREF), 56/* harmony export */ WITH_CTX: () => (/* binding */ WITH_CTX), 57/* harmony export */ WITH_DIRECTIVES: () => (/* binding */ WITH_DIRECTIVES), 58/* harmony export */ WITH_MEMO: () => (/* binding */ WITH_MEMO), 59/* harmony export */ advancePositionWithClone: () => (/* binding */ advancePositionWithClone), 60/* harmony export */ advancePositionWithMutation: () => (/* binding */ advancePositionWithMutation), 61/* harmony export */ assert: () => (/* binding */ assert), 62/* harmony export */ baseCompile: () => (/* binding */ baseCompile), 63/* harmony export */ baseParse: () => (/* binding */ baseParse), 64/* harmony export */ buildDirectiveArgs: () => (/* binding */ buildDirectiveArgs), 65/* harmony export */ buildProps: () => (/* binding */ buildProps), 66/* harmony export */ buildSlots: () => (/* binding */ buildSlots), 67/* harmony export */ checkCompatEnabled: () => (/* binding */ checkCompatEnabled), 68/* harmony export */ convertToBlock: () => (/* binding */ convertToBlock), 69/* harmony export */ createArrayExpression: () => (/* binding */ createArrayExpression), 70/* harmony export */ createAssignmentExpression: () => (/* binding */ createAssignmentExpression), 71/* harmony export */ createBlockStatement: () => (/* binding */ createBlockStatement), 72/* harmony export */ createCacheExpression: () => (/* binding */ createCacheExpression), 73/* harmony export */ createCallExpression: () => (/* binding */ createCallExpression), 74/* harmony export */ createCompilerError: () => (/* binding */ createCompilerError), 75/* harmony export */ createCompoundExpression: () => (/* binding */ createCompoundExpression), 76/* harmony export */ createConditionalExpression: () => (/* binding */ createConditionalExpression), 77/* harmony export */ createForLoopParams: () => (/* binding */ createForLoopParams), 78/* harmony export */ createFunctionExpression: () => (/* binding */ createFunctionExpression), 79/* harmony export */ createIfStatement: () => (/* binding */ createIfStatement), 80/* harmony export */ createInterpolation: () => (/* binding */ createInterpolation), 81/* harmony export */ createObjectExpression: () => (/* binding */ createObjectExpression), 82/* harmony export */ createObjectProperty: () => (/* binding */ createObjectProperty), 83/* harmony export */ createReturnStatement: () => (/* binding */ createReturnStatement), 84/* harmony export */ createRoot: () => (/* binding */ createRoot), 85/* harmony export */ createSequenceExpression: () => (/* binding */ createSequenceExpression), 86/* harmony export */ createSimpleExpression: () => (/* binding */ createSimpleExpression), 87/* harmony export */ createStructuralDirectiveTransform: () => (/* binding */ createStructuralDirectiveTransform), 88/* harmony export */ createTemplateLiteral: () => (/* binding */ createTemplateLiteral), 89/* harmony export */ createTransformContext: () => (/* binding */ createTransformContext), 90/* harmony export */ createVNodeCall: () => (/* binding */ createVNodeCall), 91/* harmony export */ errorMessages: () => (/* binding */ errorMessages), 92/* harmony export */ extractIdentifiers: () => (/* binding */ extractIdentifiers), 93/* harmony export */ findDir: () => (/* binding */ findDir), 94/* harmony export */ findProp: () => (/* binding */ findProp), 95/* harmony export */ forAliasRE: () => (/* binding */ forAliasRE), 96/* harmony export */ generate: () => (/* binding */ generate), 97/* harmony export */ generateCodeFrame: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_0__.generateCodeFrame), 98/* harmony export */ getBaseTransformPreset: () => (/* binding */ getBaseTransformPreset), 99/* harmony export */ getConstantType: () => (/* binding */ getConstantType), 100/* harmony export */ getMemoedVNodeCall: () => (/* binding */ getMemoedVNodeCall), 101/* harmony export */ getVNodeBlockHelper: () => (/* binding */ getVNodeBlockHelper), 102/* harmony export */ getVNodeHelper: () => (/* binding */ getVNodeHelper), 103/* harmony export */ hasDynamicKeyVBind: () => (/* binding */ hasDynamicKeyVBind), 104/* harmony export */ hasScopeRef: () => (/* binding */ hasScopeRef), 105/* harmony export */ helperNameMap: () => (/* binding */ helperNameMap), 106/* harmony export */ injectProp: () => (/* binding */ injectProp), 107/* harmony export */ isCoreComponent: () => (/* binding */ isCoreComponent), 108/* harmony export */ isFnExpression: () => (/* binding */ isFnExpression), 109/* harmony export */ isFnExpressionBrowser: () => (/* binding */ isFnExpressionBrowser), 110/* harmony export */ isFnExpressionNode: () => (/* binding */ isFnExpressionNode), 111/* harmony export */ isFunctionType: () => (/* binding */ isFunctionType), 112/* harmony export */ isInDestructureAssignment: () => (/* binding */ isInDestructureAssignment), 113/* harmony export */ isInNewExpression: () => (/* binding */ isInNewExpression), 114/* harmony export */ isMemberExpression: () => (/* binding */ isMemberExpression), 115/* harmony export */ isMemberExpressionBrowser: () => (/* binding */ isMemberExpressionBrowser), 116/* harmony export */ isMemberExpressionNode: () => (/* binding */ isMemberExpressionNode), 117/* harmony export */ isReferencedIdentifier: () => (/* binding */ isReferencedIdentifier), 118/* harmony export */ isSimpleIdentifier: () => (/* binding */ isSimpleIdentifier), 119/* harmony export */ isSlotOutlet: () => (/* binding */ isSlotOutlet), 120/* harmony export */ isStaticArgOf: () => (/* binding */ isStaticArgOf), 121/* harmony export */ isStaticExp: () => (/* binding */ isStaticExp), 122/* harmony export */ isStaticProperty: () => (/* binding */ isStaticProperty), 123/* harmony export */ isStaticPropertyKey: () => (/* binding */ isStaticPropertyKey), 124/* harmony export */ isTemplateNode: () => (/* binding */ isTemplateNode), 125/* harmony export */ isText: () => (/* binding */ isText$1), 126/* harmony export */ isVSlot: () => (/* binding */ isVSlot), 127/* harmony export */ locStub: () => (/* binding */ locStub), 128/* harmony export */ noopDirectiveTransform: () => (/* binding */ noopDirectiveTransform), 129/* harmony export */ processExpression: () => (/* binding */ processExpression), 130/* harmony export */ processFor: () => (/* binding */ processFor), 131/* harmony export */ processIf: () => (/* binding */ processIf), 132/* harmony export */ processSlotOutlet: () => (/* binding */ processSlotOutlet), 133/* harmony export */ registerRuntimeHelpers: () => (/* binding */ registerRuntimeHelpers), 134/* harmony export */ resolveComponentType: () => (/* binding */ resolveComponentType), 135/* harmony export */ stringifyExpression: () => (/* binding */ stringifyExpression), 136/* harmony export */ toValidAssetId: () => (/* binding */ toValidAssetId), 137/* harmony export */ trackSlotScopes: () => (/* binding */ trackSlotScopes), 138/* harmony export */ trackVForSlotScopes: () => (/* binding */ trackVForSlotScopes), 139/* harmony export */ transform: () => (/* binding */ transform), 140/* harmony export */ transformBind: () => (/* binding */ transformBind), 141/* harmony export */ transformElement: () => (/* binding */ transformElement), 142/* harmony export */ transformExpression: () => (/* binding */ transformExpression), 143/* harmony export */ transformModel: () => (/* binding */ transformModel), 144/* harmony export */ transformOn: () => (/* binding */ transformOn), 145/* harmony export */ traverseNode: () => (/* binding */ traverseNode), 146/* harmony export */ unwrapTSNode: () => (/* binding */ unwrapTSNode), 147/* harmony export */ walkBlockDeclarations: () => (/* binding */ walkBlockDeclarations), 148/* harmony export */ walkFunctionParams: () => (/* binding */ walkFunctionParams), 149/* harmony export */ walkIdentifiers: () => (/* binding */ walkIdentifiers), 150/* harmony export */ warnDeprecation: () => (/* binding */ warnDeprecation) 151/* harmony export */ }); 152/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 153/** 154* @vue/compiler-core v3.5.13 155* (c) 2018-present Yuxi (Evan) You and Vue contributors 156* @license MIT 157**/ 158 159 160 161const FRAGMENT = Symbol( true ? `Fragment` : 0); 162const TELEPORT = Symbol( true ? `Teleport` : 0); 163const SUSPENSE = Symbol( true ? `Suspense` : 0); 164const KEEP_ALIVE = Symbol( true ? `KeepAlive` : 0); 165const BASE_TRANSITION = Symbol( 166 true ? `BaseTransition` : 0 167); 168const OPEN_BLOCK = Symbol( true ? `openBlock` : 0); 169const CREATE_BLOCK = Symbol( true ? `createBlock` : 0); 170const CREATE_ELEMENT_BLOCK = Symbol( 171 true ? `createElementBlock` : 0 172); 173const CREATE_VNODE = Symbol( true ? `createVNode` : 0); 174const CREATE_ELEMENT_VNODE = Symbol( 175 true ? `createElementVNode` : 0 176); 177const CREATE_COMMENT = Symbol( 178 true ? `createCommentVNode` : 0 179); 180const CREATE_TEXT = Symbol( 181 true ? `createTextVNode` : 0 182); 183const CREATE_STATIC = Symbol( 184 true ? `createStaticVNode` : 0 185); 186const RESOLVE_COMPONENT = Symbol( 187 true ? `resolveComponent` : 0 188); 189const RESOLVE_DYNAMIC_COMPONENT = Symbol( 190 true ? `resolveDynamicComponent` : 0 191); 192const RESOLVE_DIRECTIVE = Symbol( 193 true ? `resolveDirective` : 0 194); 195const RESOLVE_FILTER = Symbol( 196 true ? `resolveFilter` : 0 197); 198const WITH_DIRECTIVES = Symbol( 199 true ? `withDirectives` : 0 200); 201const RENDER_LIST = Symbol( true ? `renderList` : 0); 202const RENDER_SLOT = Symbol( true ? `renderSlot` : 0); 203const CREATE_SLOTS = Symbol( true ? `createSlots` : 0); 204const TO_DISPLAY_STRING = Symbol( 205 true ? `toDisplayString` : 0 206); 207const MERGE_PROPS = Symbol( true ? `mergeProps` : 0); 208const NORMALIZE_CLASS = Symbol( 209 true ? `normalizeClass` : 0 210); 211const NORMALIZE_STYLE = Symbol( 212 true ? `normalizeStyle` : 0 213); 214const NORMALIZE_PROPS = Symbol( 215 true ? `normalizeProps` : 0 216); 217const GUARD_REACTIVE_PROPS = Symbol( 218 true ? `guardReactiveProps` : 0 219); 220const TO_HANDLERS = Symbol( true ? `toHandlers` : 0); 221const CAMELIZE = Symbol( true ? `camelize` : 0); 222const CAPITALIZE = Symbol( true ? `capitalize` : 0); 223const TO_HANDLER_KEY = Symbol( 224 true ? `toHandlerKey` : 0 225); 226const SET_BLOCK_TRACKING = Symbol( 227 true ? `setBlockTracking` : 0 228); 229const PUSH_SCOPE_ID = Symbol( true ? `pushScopeId` : 0); 230const POP_SCOPE_ID = Symbol( true ? `popScopeId` : 0); 231const WITH_CTX = Symbol( true ? `withCtx` : 0); 232const UNREF = Symbol( true ? `unref` : 0); 233const IS_REF = Symbol( true ? `isRef` : 0); 234const WITH_MEMO = Symbol( true ? `withMemo` : 0); 235const IS_MEMO_SAME = Symbol( true ? `isMemoSame` : 0); 236const helperNameMap = { 237 [FRAGMENT]: `Fragment`, 238 [TELEPORT]: `Teleport`, 239 [SUSPENSE]: `Suspense`, 240 [KEEP_ALIVE]: `KeepAlive`, 241 [BASE_TRANSITION]: `BaseTransition`, 242 [OPEN_BLOCK]: `openBlock`, 243 [CREATE_BLOCK]: `createBlock`, 244 [CREATE_ELEMENT_BLOCK]: `createElementBlock`, 245 [CREATE_VNODE]: `createVNode`, 246 [CREATE_ELEMENT_VNODE]: `createElementVNode`, 247 [CREATE_COMMENT]: `createCommentVNode`, 248 [CREATE_TEXT]: `createTextVNode`, 249 [CREATE_STATIC]: `createStaticVNode`, 250 [RESOLVE_COMPONENT]: `resolveComponent`, 251 [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`, 252 [RESOLVE_DIRECTIVE]: `resolveDirective`, 253 [RESOLVE_FILTER]: `resolveFilter`, 254 [WITH_DIRECTIVES]: `withDirectives`, 255 [RENDER_LIST]: `renderList`, 256 [RENDER_SLOT]: `renderSlot`, 257 [CREATE_SLOTS]: `createSlots`, 258 [TO_DISPLAY_STRING]: `toDisplayString`, 259 [MERGE_PROPS]: `mergeProps`, 260 [NORMALIZE_CLASS]: `normalizeClass`, 261 [NORMALIZE_STYLE]: `normalizeStyle`, 262 [NORMALIZE_PROPS]: `normalizeProps`, 263 [GUARD_REACTIVE_PROPS]: `guardReactiveProps`, 264 [TO_HANDLERS]: `toHandlers`, 265 [CAMELIZE]: `camelize`, 266 [CAPITALIZE]: `capitalize`, 267 [TO_HANDLER_KEY]: `toHandlerKey`, 268 [SET_BLOCK_TRACKING]: `setBlockTracking`, 269 [PUSH_SCOPE_ID]: `pushScopeId`, 270 [POP_SCOPE_ID]: `popScopeId`, 271 [WITH_CTX]: `withCtx`, 272 [UNREF]: `unref`, 273 [IS_REF]: `isRef`, 274 [WITH_MEMO]: `withMemo`, 275 [IS_MEMO_SAME]: `isMemoSame` 276}; 277function registerRuntimeHelpers(helpers) { 278 Object.getOwnPropertySymbols(helpers).forEach((s) => { 279 helperNameMap[s] = helpers[s]; 280 }); 281} 282 283const Namespaces = { 284 "HTML": 0, 285 "0": "HTML", 286 "SVG": 1, 287 "1": "SVG", 288 "MATH_ML": 2, 289 "2": "MATH_ML" 290}; 291const NodeTypes = { 292 "ROOT": 0, 293 "0": "ROOT", 294 "ELEMENT": 1, 295 "1": "ELEMENT", 296 "TEXT": 2, 297 "2": "TEXT", 298 "COMMENT": 3, 299 "3": "COMMENT", 300 "SIMPLE_EXPRESSION": 4, 301 "4": "SIMPLE_EXPRESSION", 302 "INTERPOLATION": 5, 303 "5": "INTERPOLATION", 304 "ATTRIBUTE": 6, 305 "6": "ATTRIBUTE", 306 "DIRECTIVE": 7, 307 "7": "DIRECTIVE", 308 "COMPOUND_EXPRESSION": 8, 309 "8": "COMPOUND_EXPRESSION", 310 "IF": 9, 311 "9": "IF", 312 "IF_BRANCH": 10, 313 "10": "IF_BRANCH", 314 "FOR": 11, 315 "11": "FOR", 316 "TEXT_CALL": 12, 317 "12": "TEXT_CALL", 318 "VNODE_CALL": 13, 319 "13": "VNODE_CALL", 320 "JS_CALL_EXPRESSION": 14, 321 "14": "JS_CALL_EXPRESSION", 322 "JS_OBJECT_EXPRESSION": 15, 323 "15": "JS_OBJECT_EXPRESSION", 324 "JS_PROPERTY": 16, 325 "16": "JS_PROPERTY", 326 "JS_ARRAY_EXPRESSION": 17, 327 "17": "JS_ARRAY_EXPRESSION", 328 "JS_FUNCTION_EXPRESSION": 18, 329 "18": "JS_FUNCTION_EXPRESSION", 330 "JS_CONDITIONAL_EXPRESSION": 19, 331 "19": "JS_CONDITIONAL_EXPRESSION", 332 "JS_CACHE_EXPRESSION": 20, 333 "20": "JS_CACHE_EXPRESSION", 334 "JS_BLOCK_STATEMENT": 21, 335 "21": "JS_BLOCK_STATEMENT", 336 "JS_TEMPLATE_LITERAL": 22, 337 "22": "JS_TEMPLATE_LITERAL", 338 "JS_IF_STATEMENT": 23, 339 "23": "JS_IF_STATEMENT", 340 "JS_ASSIGNMENT_EXPRESSION": 24, 341 "24": "JS_ASSIGNMENT_EXPRESSION", 342 "JS_SEQUENCE_EXPRESSION": 25, 343 "25": "JS_SEQUENCE_EXPRESSION", 344 "JS_RETURN_STATEMENT": 26, 345 "26": "JS_RETURN_STATEMENT" 346}; 347const ElementTypes = { 348 "ELEMENT": 0, 349 "0": "ELEMENT", 350 "COMPONENT": 1, 351 "1": "COMPONENT", 352 "SLOT": 2, 353 "2": "SLOT", 354 "TEMPLATE": 3, 355 "3": "TEMPLATE" 356}; 357const ConstantTypes = { 358 "NOT_CONSTANT": 0, 359 "0": "NOT_CONSTANT", 360 "CAN_SKIP_PATCH": 1, 361 "1": "CAN_SKIP_PATCH", 362 "CAN_CACHE": 2, 363 "2": "CAN_CACHE", 364 "CAN_STRINGIFY": 3, 365 "3": "CAN_STRINGIFY" 366}; 367const locStub = { 368 start: { line: 1, column: 1, offset: 0 }, 369 end: { line: 1, column: 1, offset: 0 }, 370 source: "" 371}; 372function createRoot(children, source = "") { 373 return { 374 type: 0, 375 source, 376 children, 377 helpers: /* @__PURE__ */ new Set(), 378 components: [], 379 directives: [], 380 hoists: [], 381 imports: [], 382 cached: [], 383 temps: 0, 384 codegenNode: void 0, 385 loc: locStub 386 }; 387} 388function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) { 389 if (context) { 390 if (isBlock) { 391 context.helper(OPEN_BLOCK); 392 context.helper(getVNodeBlockHelper(context.inSSR, isComponent)); 393 } else { 394 context.helper(getVNodeHelper(context.inSSR, isComponent)); 395 } 396 if (directives) { 397 context.helper(WITH_DIRECTIVES); 398 } 399 } 400 return { 401 type: 13, 402 tag, 403 props, 404 children, 405 patchFlag, 406 dynamicProps, 407 directives, 408 isBlock, 409 disableTracking, 410 isComponent, 411 loc 412 }; 413} 414function createArrayExpression(elements, loc = locStub) { 415 return { 416 type: 17, 417 loc, 418 elements 419 }; 420} 421function createObjectExpression(properties, loc = locStub) { 422 return { 423 type: 15, 424 loc, 425 properties 426 }; 427} 428function createObjectProperty(key, value) { 429 return { 430 type: 16, 431 loc: locStub, 432 key: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(key) ? createSimpleExpression(key, true) : key, 433 value 434 }; 435} 436function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) { 437 return { 438 type: 4, 439 loc, 440 content, 441 isStatic, 442 constType: isStatic ? 3 : constType 443 }; 444} 445function createInterpolation(content, loc) { 446 return { 447 type: 5, 448 loc, 449 content: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(content) ? createSimpleExpression(content, false, loc) : content 450 }; 451} 452function createCompoundExpression(children, loc = locStub) { 453 return { 454 type: 8, 455 loc, 456 children 457 }; 458} 459function createCallExpression(callee, args = [], loc = locStub) { 460 return { 461 type: 14, 462 loc, 463 callee, 464 arguments: args 465 }; 466} 467function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) { 468 return { 469 type: 18, 470 params, 471 returns, 472 newline, 473 isSlot, 474 loc 475 }; 476} 477function createConditionalExpression(test, consequent, alternate, newline = true) { 478 return { 479 type: 19, 480 test, 481 consequent, 482 alternate, 483 newline, 484 loc: locStub 485 }; 486} 487function createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) { 488 return { 489 type: 20, 490 index, 491 value, 492 needPauseTracking, 493 inVOnce, 494 needArraySpread: false, 495 loc: locStub 496 }; 497} 498function createBlockStatement(body) { 499 return { 500 type: 21, 501 body, 502 loc: locStub 503 }; 504} 505function createTemplateLiteral(elements) { 506 return { 507 type: 22, 508 elements, 509 loc: locStub 510 }; 511} 512function createIfStatement(test, consequent, alternate) { 513 return { 514 type: 23, 515 test, 516 consequent, 517 alternate, 518 loc: locStub 519 }; 520} 521function createAssignmentExpression(left, right) { 522 return { 523 type: 24, 524 left, 525 right, 526 loc: locStub 527 }; 528} 529function createSequenceExpression(expressions) { 530 return { 531 type: 25, 532 expressions, 533 loc: locStub 534 }; 535} 536function createReturnStatement(returns) { 537 return { 538 type: 26, 539 returns, 540 loc: locStub 541 }; 542} 543function getVNodeHelper(ssr, isComponent) { 544 return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE; 545} 546function getVNodeBlockHelper(ssr, isComponent) { 547 return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK; 548} 549function convertToBlock(node, { helper, removeHelper, inSSR }) { 550 if (!node.isBlock) { 551 node.isBlock = true; 552 removeHelper(getVNodeHelper(inSSR, node.isComponent)); 553 helper(OPEN_BLOCK); 554 helper(getVNodeBlockHelper(inSSR, node.isComponent)); 555 } 556} 557 558const defaultDelimitersOpen = new Uint8Array([123, 123]); 559const defaultDelimitersClose = new Uint8Array([125, 125]); 560function isTagStartChar(c) { 561 return c >= 97 && c <= 122 || c >= 65 && c <= 90; 562} 563function isWhitespace(c) { 564 return c === 32 || c === 10 || c === 9 || c === 12 || c === 13; 565} 566function isEndOfTagSection(c) { 567 return c === 47 || c === 62 || isWhitespace(c); 568} 569function toCharCodes(str) { 570 const ret = new Uint8Array(str.length); 571 for (let i = 0; i < str.length; i++) { 572 ret[i] = str.charCodeAt(i); 573 } 574 return ret; 575} 576const Sequences = { 577 Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]), 578 // CDATA[ 579 CdataEnd: new Uint8Array([93, 93, 62]), 580 // ]]> 581 CommentEnd: new Uint8Array([45, 45, 62]), 582 // `-->` 583 ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]), 584 // `<\/script` 585 StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]), 586 // `</style` 587 TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]), 588 // `</title` 589 TextareaEnd: new Uint8Array([ 590 60, 591 47, 592 116, 593 101, 594 120, 595 116, 596 97, 597 114, 598 101, 599 97 600 ]) 601 // `</textarea 602}; 603class Tokenizer { 604 constructor(stack, cbs) { 605 this.stack = stack; 606 this.cbs = cbs; 607 /** The current state the tokenizer is in. */ 608 this.state = 1; 609 /** The read buffer. */ 610 this.buffer = ""; 611 /** The beginning of the section that is currently being read. */ 612 this.sectionStart = 0; 613 /** The index within the buffer that we are currently looking at. */ 614 this.index = 0; 615 /** The start of the last entity. */ 616 this.entityStart = 0; 617 /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */ 618 this.baseState = 1; 619 /** For special parsing behavior inside of script and style tags. */ 620 this.inRCDATA = false; 621 /** For disabling RCDATA tags handling */ 622 this.inXML = false; 623 /** For disabling interpolation parsing in v-pre */ 624 this.inVPre = false; 625 /** Record newline positions for fast line / column calculation */ 626 this.newlines = []; 627 this.mode = 0; 628 this.delimiterOpen = defaultDelimitersOpen; 629 this.delimiterClose = defaultDelimitersClose; 630 this.delimiterIndex = -1; 631 this.currentSequence = void 0; 632 this.sequenceIndex = 0; 633 } 634 get inSFCRoot() { 635 return this.mode === 2 && this.stack.length === 0; 636 } 637 reset() { 638 this.state = 1; 639 this.mode = 0; 640 this.buffer = ""; 641 this.sectionStart = 0; 642 this.index = 0; 643 this.baseState = 1; 644 this.inRCDATA = false; 645 this.currentSequence = void 0; 646 this.newlines.length = 0; 647 this.delimiterOpen = defaultDelimitersOpen; 648 this.delimiterClose = defaultDelimitersClose; 649 } 650 /** 651 * Generate Position object with line / column information using recorded 652 * newline positions. We know the index is always going to be an already 653 * processed index, so all the newlines up to this index should have been 654 * recorded. 655 */ 656 getPos(index) { 657 let line = 1; 658 let column = index + 1; 659 for (let i = this.newlines.length - 1; i >= 0; i--) { 660 const newlineIndex = this.newlines[i]; 661 if (index > newlineIndex) { 662 line = i + 2; 663 column = index - newlineIndex; 664 break; 665 } 666 } 667 return { 668 column, 669 line, 670 offset: index 671 }; 672 } 673 peek() { 674 return this.buffer.charCodeAt(this.index + 1); 675 } 676 stateText(c) { 677 if (c === 60) { 678 if (this.index > this.sectionStart) { 679 this.cbs.ontext(this.sectionStart, this.index); 680 } 681 this.state = 5; 682 this.sectionStart = this.index; 683 } else if (!this.inVPre && c === this.delimiterOpen[0]) { 684 this.state = 2; 685 this.delimiterIndex = 0; 686 this.stateInterpolationOpen(c); 687 } 688 } 689 stateInterpolationOpen(c) { 690 if (c === this.delimiterOpen[this.delimiterIndex]) { 691 if (this.delimiterIndex === this.delimiterOpen.length - 1) { 692 const start = this.index + 1 - this.delimiterOpen.length; 693 if (start > this.sectionStart) { 694 this.cbs.ontext(this.sectionStart, start); 695 } 696 this.state = 3; 697 this.sectionStart = start; 698 } else { 699 this.delimiterIndex++; 700 } 701 } else if (this.inRCDATA) { 702 this.state = 32; 703 this.stateInRCDATA(c); 704 } else { 705 this.state = 1; 706 this.stateText(c); 707 } 708 } 709 stateInterpolation(c) { 710 if (c === this.delimiterClose[0]) { 711 this.state = 4; 712 this.delimiterIndex = 0; 713 this.stateInterpolationClose(c); 714 } 715 } 716 stateInterpolationClose(c) { 717 if (c === this.delimiterClose[this.delimiterIndex]) { 718 if (this.delimiterIndex === this.delimiterClose.length - 1) { 719 this.cbs.oninterpolation(this.sectionStart, this.index + 1); 720 if (this.inRCDATA) { 721 this.state = 32; 722 } else { 723 this.state = 1; 724 } 725 this.sectionStart = this.index + 1; 726 } else { 727 this.delimiterIndex++; 728 } 729 } else { 730 this.state = 3; 731 this.stateInterpolation(c); 732 } 733 } 734 stateSpecialStartSequence(c) { 735 const isEnd = this.sequenceIndex === this.currentSequence.length; 736 const isMatch = isEnd ? ( 737 // If we are at the end of the sequence, make sure the tag name has ended 738 isEndOfTagSection(c) 739 ) : ( 740 // Otherwise, do a case-insensitive comparison 741 (c | 32) === this.currentSequence[this.sequenceIndex] 742 ); 743 if (!isMatch) { 744 this.inRCDATA = false; 745 } else if (!isEnd) { 746 this.sequenceIndex++; 747 return; 748 } 749 this.sequenceIndex = 0; 750 this.state = 6; 751 this.stateInTagName(c); 752 } 753 /** Look for an end tag. For <title> and <textarea>, also decode entities. */ 754 stateInRCDATA(c) { 755 if (this.sequenceIndex === this.currentSequence.length) { 756 if (c === 62 || isWhitespace(c)) { 757 const endOfText = this.index - this.currentSequence.length; 758 if (this.sectionStart < endOfText) { 759 const actualIndex = this.index; 760 this.index = endOfText; 761 this.cbs.ontext(this.sectionStart, endOfText); 762 this.index = actualIndex; 763 } 764 this.sectionStart = endOfText + 2; 765 this.stateInClosingTagName(c); 766 this.inRCDATA = false; 767 return; 768 } 769 this.sequenceIndex = 0; 770 } 771 if ((c | 32) === this.currentSequence[this.sequenceIndex]) { 772 this.sequenceIndex += 1; 773 } else if (this.sequenceIndex === 0) { 774 if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) { 775 if (!this.inVPre && c === this.delimiterOpen[0]) { 776 this.state = 2; 777 this.delimiterIndex = 0; 778 this.stateInterpolationOpen(c); 779 } 780 } else if (this.fastForwardTo(60)) { 781 this.sequenceIndex = 1; 782 } 783 } else { 784 this.sequenceIndex = Number(c === 60); 785 } 786 } 787 stateCDATASequence(c) { 788 if (c === Sequences.Cdata[this.sequenceIndex]) { 789 if (++this.sequenceIndex === Sequences.Cdata.length) { 790 this.state = 28; 791 this.currentSequence = Sequences.CdataEnd; 792 this.sequenceIndex = 0; 793 this.sectionStart = this.index + 1; 794 } 795 } else { 796 this.sequenceIndex = 0; 797 this.state = 23; 798 this.stateInDeclaration(c); 799 } 800 } 801 /** 802 * When we wait for one specific character, we can speed things up 803 * by skipping through the buffer until we find it. 804 * 805 * @returns Whether the character was found. 806 */ 807 fastForwardTo(c) { 808 while (++this.index < this.buffer.length) { 809 const cc = this.buffer.charCodeAt(this.index); 810 if (cc === 10) { 811 this.newlines.push(this.index); 812 } 813 if (cc === c) { 814 return true; 815 } 816 } 817 this.index = this.buffer.length - 1; 818 return false; 819 } 820 /** 821 * Comments and CDATA end with `-->` and `]]>`. 822 * 823 * Their common qualities are: 824 * - Their end sequences have a distinct character they start with. 825 * - That character is then repeated, so we have to check multiple repeats. 826 * - All characters but the start character of the sequence can be skipped. 827 */ 828 stateInCommentLike(c) { 829 if (c === this.currentSequence[this.sequenceIndex]) { 830 if (++this.sequenceIndex === this.currentSequence.length) { 831 if (this.currentSequence === Sequences.CdataEnd) { 832 this.cbs.oncdata(this.sectionStart, this.index - 2); 833 } else { 834 this.cbs.oncomment(this.sectionStart, this.index - 2); 835 } 836 this.sequenceIndex = 0; 837 this.sectionStart = this.index + 1; 838 this.state = 1; 839 } 840 } else if (this.sequenceIndex === 0) { 841 if (this.fastForwardTo(this.currentSequence[0])) { 842 this.sequenceIndex = 1; 843 } 844 } else if (c !== this.currentSequence[this.sequenceIndex - 1]) { 845 this.sequenceIndex = 0; 846 } 847 } 848 startSpecial(sequence, offset) { 849 this.enterRCDATA(sequence, offset); 850 this.state = 31; 851 } 852 enterRCDATA(sequence, offset) { 853 this.inRCDATA = true; 854 this.currentSequence = sequence; 855 this.sequenceIndex = offset; 856 } 857 stateBeforeTagName(c) { 858 if (c === 33) { 859 this.state = 22; 860 this.sectionStart = this.index + 1; 861 } else if (c === 63) { 862 this.state = 24; 863 this.sectionStart = this.index + 1; 864 } else if (isTagStartChar(c)) { 865 this.sectionStart = this.index; 866 if (this.mode === 0) { 867 this.state = 6; 868 } else if (this.inSFCRoot) { 869 this.state = 34; 870 } else if (!this.inXML) { 871 if (c === 116) { 872 this.state = 30; 873 } else { 874 this.state = c === 115 ? 29 : 6; 875 } 876 } else { 877 this.state = 6; 878 } 879 } else if (c === 47) { 880 this.state = 8; 881 } else { 882 this.state = 1; 883 this.stateText(c); 884 } 885 } 886 stateInTagName(c) { 887 if (isEndOfTagSection(c)) { 888 this.handleTagName(c); 889 } 890 } 891 stateInSFCRootTagName(c) { 892 if (isEndOfTagSection(c)) { 893 const tag = this.buffer.slice(this.sectionStart, this.index); 894 if (tag !== "template") { 895 this.enterRCDATA(toCharCodes(`</` + tag), 0); 896 } 897 this.handleTagName(c); 898 } 899 } 900 handleTagName(c) { 901 this.cbs.onopentagname(this.sectionStart, this.index); 902 this.sectionStart = -1; 903 this.state = 11; 904 this.stateBeforeAttrName(c); 905 } 906 stateBeforeClosingTagName(c) { 907 if (isWhitespace(c)) ; else if (c === 62) { 908 if (true) { 909 this.cbs.onerr(14, this.index); 910 } 911 this.state = 1; 912 this.sectionStart = this.index + 1; 913 } else { 914 this.state = isTagStartChar(c) ? 9 : 27; 915 this.sectionStart = this.index; 916 } 917 } 918 stateInClosingTagName(c) { 919 if (c === 62 || isWhitespace(c)) { 920 this.cbs.onclosetag(this.sectionStart, this.index); 921 this.sectionStart = -1; 922 this.state = 10; 923 this.stateAfterClosingTagName(c); 924 } 925 } 926 stateAfterClosingTagName(c) { 927 if (c === 62) { 928 this.state = 1; 929 this.sectionStart = this.index + 1; 930 } 931 } 932 stateBeforeAttrName(c) { 933 if (c === 62) { 934 this.cbs.onopentagend(this.index); 935 if (this.inRCDATA) { 936 this.state = 32; 937 } else { 938 this.state = 1; 939 } 940 this.sectionStart = this.index + 1; 941 } else if (c === 47) { 942 this.state = 7; 943 if (( true) && this.peek() !== 62) { 944 this.cbs.onerr(22, this.index); 945 } 946 } else if (c === 60 && this.peek() === 47) { 947 this.cbs.onopentagend(this.index); 948 this.state = 5; 949 this.sectionStart = this.index; 950 } else if (!isWhitespace(c)) { 951 if (( true) && c === 61) { 952 this.cbs.onerr( 953 19, 954 this.index 955 ); 956 } 957 this.handleAttrStart(c); 958 } 959 } 960 handleAttrStart(c) { 961 if (c === 118 && this.peek() === 45) { 962 this.state = 13; 963 this.sectionStart = this.index; 964 } else if (c === 46 || c === 58 || c === 64 || c === 35) { 965 this.cbs.ondirname(this.index, this.index + 1); 966 this.state = 14; 967 this.sectionStart = this.index + 1; 968 } else { 969 this.state = 12; 970 this.sectionStart = this.index; 971 } 972 } 973 stateInSelfClosingTag(c) { 974 if (c === 62) { 975 this.cbs.onselfclosingtag(this.index); 976 this.state = 1; 977 this.sectionStart = this.index + 1; 978 this.inRCDATA = false; 979 } else if (!isWhitespace(c)) { 980 this.state = 11; 981 this.stateBeforeAttrName(c); 982 } 983 } 984 stateInAttrName(c) { 985 if (c === 61 || isEndOfTagSection(c)) { 986 this.cbs.onattribname(this.sectionStart, this.index); 987 this.handleAttrNameEnd(c); 988 } else if (( true) && (c === 34 || c === 39 || c === 60)) { 989 this.cbs.onerr( 990 17, 991 this.index 992 ); 993 } 994 } 995 stateInDirName(c) { 996 if (c === 61 || isEndOfTagSection(c)) { 997 this.cbs.ondirname(this.sectionStart, this.index); 998 this.handleAttrNameEnd(c); 999 } else if (c === 58) { 1000 this.cbs.ondirname(this.sectionStart, this.index); 1001 this.state = 14; 1002 this.sectionStart = this.index + 1; 1003 } else if (c === 46) { 1004 this.cbs.ondirname(this.sectionStart, this.index); 1005 this.state = 16; 1006 this.sectionStart = this.index + 1; 1007 } 1008 } 1009 stateInDirArg(c) { 1010 if (c === 61 || isEndOfTagSection(c)) { 1011 this.cbs.ondirarg(this.sectionStart, this.index); 1012 this.handleAttrNameEnd(c); 1013 } else if (c === 91) { 1014 this.state = 15; 1015 } else if (c === 46) { 1016 this.cbs.ondirarg(this.sectionStart, this.index); 1017 this.state = 16; 1018 this.sectionStart = this.index + 1; 1019 } 1020 } 1021 stateInDynamicDirArg(c) { 1022 if (c === 93) { 1023 this.state = 14; 1024 } else if (c === 61 || isEndOfTagSection(c)) { 1025 this.cbs.ondirarg(this.sectionStart, this.index + 1); 1026 this.handleAttrNameEnd(c); 1027 if (true) { 1028 this.cbs.onerr( 1029 27, 1030 this.index 1031 ); 1032 } 1033 } 1034 } 1035 stateInDirModifier(c) { 1036 if (c === 61 || isEndOfTagSection(c)) { 1037 this.cbs.ondirmodifier(this.sectionStart, this.index); 1038 this.handleAttrNameEnd(c); 1039 } else if (c === 46) { 1040 this.cbs.ondirmodifier(this.sectionStart, this.index); 1041 this.sectionStart = this.index + 1; 1042 } 1043 } 1044 handleAttrNameEnd(c) { 1045 this.sectionStart = this.index; 1046 this.state = 17; 1047 this.cbs.onattribnameend(this.index); 1048 this.stateAfterAttrName(c); 1049 } 1050 stateAfterAttrName(c) { 1051 if (c === 61) { 1052 this.state = 18; 1053 } else if (c === 47 || c === 62) { 1054 this.cbs.onattribend(0, this.sectionStart); 1055 this.sectionStart = -1; 1056 this.state = 11; 1057 this.stateBeforeAttrName(c); 1058 } else if (!isWhitespace(c)) { 1059 this.cbs.onattribend(0, this.sectionStart); 1060 this.handleAttrStart(c); 1061 } 1062 } 1063 stateBeforeAttrValue(c) { 1064 if (c === 34) { 1065 this.state = 19; 1066 this.sectionStart = this.index + 1; 1067 } else if (c === 39) { 1068 this.state = 20; 1069 this.sectionStart = this.index + 1; 1070 } else if (!isWhitespace(c)) { 1071 this.sectionStart = this.index; 1072 this.state = 21; 1073 this.stateInAttrValueNoQuotes(c); 1074 } 1075 } 1076 handleInAttrValue(c, quote) { 1077 if (c === quote || this.fastForwardTo(quote)) { 1078 this.cbs.onattribdata(this.sectionStart, this.index); 1079 this.sectionStart = -1; 1080 this.cbs.onattribend( 1081 quote === 34 ? 3 : 2, 1082 this.index + 1 1083 ); 1084 this.state = 11; 1085 } 1086 } 1087 stateInAttrValueDoubleQuotes(c) { 1088 this.handleInAttrValue(c, 34); 1089 } 1090 stateInAttrValueSingleQuotes(c) { 1091 this.handleInAttrValue(c, 39); 1092 } 1093 stateInAttrValueNoQuotes(c) { 1094 if (isWhitespace(c) || c === 62) { 1095 this.cbs.onattribdata(this.sectionStart, this.index); 1096 this.sectionStart = -1; 1097 this.cbs.onattribend(1, this.index); 1098 this.state = 11; 1099 this.stateBeforeAttrName(c); 1100 } else if (( true) && c === 34 || c === 39 || c === 60 || c === 61 || c === 96) { 1101 this.cbs.onerr( 1102 18, 1103 this.index 1104 ); 1105 } else ; 1106 } 1107 stateBeforeDeclaration(c) { 1108 if (c === 91) { 1109 this.state = 26; 1110 this.sequenceIndex = 0; 1111 } else { 1112 this.state = c === 45 ? 25 : 23; 1113 } 1114 } 1115 stateInDeclaration(c) { 1116 if (c === 62 || this.fastForwardTo(62)) { 1117 this.state = 1; 1118 this.sectionStart = this.index + 1; 1119 } 1120 } 1121 stateInProcessingInstruction(c) { 1122 if (c === 62 || this.fastForwardTo(62)) { 1123 this.cbs.onprocessinginstruction(this.sectionStart, this.index); 1124 this.state = 1; 1125 this.sectionStart = this.index + 1; 1126 } 1127 } 1128 stateBeforeComment(c) { 1129 if (c === 45) { 1130 this.state = 28; 1131 this.currentSequence = Sequences.CommentEnd; 1132 this.sequenceIndex = 2; 1133 this.sectionStart = this.index + 1; 1134 } else { 1135 this.state = 23; 1136 } 1137 } 1138 stateInSpecialComment(c) { 1139 if (c === 62 || this.fastForwardTo(62)) { 1140 this.cbs.oncomment(this.sectionStart, this.index); 1141 this.state = 1; 1142 this.sectionStart = this.index + 1; 1143 } 1144 } 1145 stateBeforeSpecialS(c) { 1146 if (c === Sequences.ScriptEnd[3]) { 1147 this.startSpecial(Sequences.ScriptEnd, 4); 1148 } else if (c === Sequences.StyleEnd[3]) { 1149 this.startSpecial(Sequences.StyleEnd, 4); 1150 } else { 1151 this.state = 6; 1152 this.stateInTagName(c); 1153 } 1154 } 1155 stateBeforeSpecialT(c) { 1156 if (c === Sequences.TitleEnd[3]) { 1157 this.startSpecial(Sequences.TitleEnd, 4); 1158 } else if (c === Sequences.TextareaEnd[3]) { 1159 this.startSpecial(Sequences.TextareaEnd, 4); 1160 } else { 1161 this.state = 6; 1162 this.stateInTagName(c); 1163 } 1164 } 1165 startEntity() { 1166 } 1167 stateInEntity() { 1168 } 1169 /** 1170 * Iterates through the buffer, calling the function corresponding to the current state. 1171 * 1172 * States that are more likely to be hit are higher up, as a performance improvement. 1173 */ 1174 parse(input) { 1175 this.buffer = input; 1176 while (this.index < this.buffer.length) { 1177 const c = this.buffer.charCodeAt(this.index); 1178 if (c === 10) { 1179 this.newlines.push(this.index); 1180 } 1181 switch (this.state) { 1182 case 1: { 1183 this.stateText(c); 1184 break; 1185 } 1186 case 2: { 1187 this.stateInterpolationOpen(c); 1188 break; 1189 } 1190 case 3: { 1191 this.stateInterpolation(c); 1192 break; 1193 } 1194 case 4: { 1195 this.stateInterpolationClose(c); 1196 break; 1197 } 1198 case 31: { 1199 this.stateSpecialStartSequence(c); 1200 break; 1201 } 1202 case 32: { 1203 this.stateInRCDATA(c); 1204 break; 1205 } 1206 case 26: { 1207 this.stateCDATASequence(c); 1208 break; 1209 } 1210 case 19: { 1211 this.stateInAttrValueDoubleQuotes(c); 1212 break; 1213 } 1214 case 12: { 1215 this.stateInAttrName(c); 1216 break; 1217 } 1218 case 13: { 1219 this.stateInDirName(c); 1220 break; 1221 } 1222 case 14: { 1223 this.stateInDirArg(c); 1224 break; 1225 } 1226 case 15: { 1227 this.stateInDynamicDirArg(c); 1228 break; 1229 } 1230 case 16: { 1231 this.stateInDirModifier(c); 1232 break; 1233 } 1234 case 28: { 1235 this.stateInCommentLike(c); 1236 break; 1237 } 1238 case 27: { 1239 this.stateInSpecialComment(c); 1240 break; 1241 } 1242 case 11: { 1243 this.stateBeforeAttrName(c); 1244 break; 1245 } 1246 case 6: { 1247 this.stateInTagName(c); 1248 break; 1249 } 1250 case 34: { 1251 this.stateInSFCRootTagName(c); 1252 break; 1253 } 1254 case 9: { 1255 this.stateInClosingTagName(c); 1256 break; 1257 } 1258 case 5: { 1259 this.stateBeforeTagName(c); 1260 break; 1261 } 1262 case 17: { 1263 this.stateAfterAttrName(c); 1264 break; 1265 } 1266 case 20: { 1267 this.stateInAttrValueSingleQuotes(c); 1268 break; 1269 } 1270 case 18: { 1271 this.stateBeforeAttrValue(c); 1272 break; 1273 } 1274 case 8: { 1275 this.stateBeforeClosingTagName(c); 1276 break; 1277 } 1278 case 10: { 1279 this.stateAfterClosingTagName(c); 1280 break; 1281 } 1282 case 29: { 1283 this.stateBeforeSpecialS(c); 1284 break; 1285 } 1286 case 30: { 1287 this.stateBeforeSpecialT(c); 1288 break; 1289 } 1290 case 21: { 1291 this.stateInAttrValueNoQuotes(c); 1292 break; 1293 } 1294 case 7: { 1295 this.stateInSelfClosingTag(c); 1296 break; 1297 } 1298 case 23: { 1299 this.stateInDeclaration(c); 1300 break; 1301 } 1302 case 22: { 1303 this.stateBeforeDeclaration(c); 1304 break; 1305 } 1306 case 25: { 1307 this.stateBeforeComment(c); 1308 break; 1309 } 1310 case 24: { 1311 this.stateInProcessingInstruction(c); 1312 break; 1313 } 1314 case 33: { 1315 this.stateInEntity(); 1316 break; 1317 } 1318 } 1319 this.index++; 1320 } 1321 this.cleanup(); 1322 this.finish(); 1323 } 1324 /** 1325 * Remove data that has already been consumed from the buffer. 1326 */ 1327 cleanup() { 1328 if (this.sectionStart !== this.index) { 1329 if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) { 1330 this.cbs.ontext(this.sectionStart, this.index); 1331 this.sectionStart = this.index; 1332 } else if (this.state === 19 || this.state === 20 || this.state === 21) { 1333 this.cbs.onattribdata(this.sectionStart, this.index); 1334 this.sectionStart = this.index; 1335 } 1336 } 1337 } 1338 finish() { 1339 this.handleTrailingData(); 1340 this.cbs.onend(); 1341 } 1342 /** Handle any trailing data. */ 1343 handleTrailingData() { 1344 const endIndex = this.buffer.length; 1345 if (this.sectionStart >= endIndex) { 1346 return; 1347 } 1348 if (this.state === 28) { 1349 if (this.currentSequence === Sequences.CdataEnd) { 1350 this.cbs.oncdata(this.sectionStart, endIndex); 1351 } else { 1352 this.cbs.oncomment(this.sectionStart, endIndex); 1353 } 1354 } else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ; else { 1355 this.cbs.ontext(this.sectionStart, endIndex); 1356 } 1357 } 1358 emitCodePoint(cp, consumed) { 1359 } 1360} 1361 1362const CompilerDeprecationTypes = { 1363 "COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT", 1364 "COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC", 1365 "COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER", 1366 "COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE", 1367 "COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE", 1368 "COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE", 1369 "COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE", 1370 "COMPILER_FILTERS": "COMPILER_FILTERS" 1371}; 1372const deprecationData = { 1373 ["COMPILER_IS_ON_ELEMENT"]: { 1374 message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`, 1375 link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html` 1376 }, 1377 ["COMPILER_V_BIND_SYNC"]: { 1378 message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`, 1379 link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html` 1380 }, 1381 ["COMPILER_V_BIND_OBJECT_ORDER"]: { 1382 message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`, 1383 link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html` 1384 }, 1385 ["COMPILER_V_ON_NATIVE"]: { 1386 message: `.native modifier for v-on has been removed as is no longer necessary.`, 1387 link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html` 1388 }, 1389 ["COMPILER_V_IF_V_FOR_PRECEDENCE"]: { 1390 message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`, 1391 link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html` 1392 }, 1393 ["COMPILER_NATIVE_TEMPLATE"]: { 1394 message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.` 1395 }, 1396 ["COMPILER_INLINE_TEMPLATE"]: { 1397 message: `"inline-template" has been removed in Vue 3.`, 1398 link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html` 1399 }, 1400 ["COMPILER_FILTERS"]: { 1401 message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`, 1402 link: `https://v3-migration.vuejs.org/breaking-changes/filters.html` 1403 } 1404}; 1405function getCompatValue(key, { compatConfig }) { 1406 const value = compatConfig && compatConfig[key]; 1407 if (key === "MODE") { 1408 return value || 3; 1409 } else { 1410 return value; 1411 } 1412} 1413function isCompatEnabled(key, context) { 1414 const mode = getCompatValue("MODE", context); 1415 const value = getCompatValue(key, context); 1416 return mode === 3 ? value === true : value !== false; 1417} 1418function checkCompatEnabled(key, context, loc, ...args) { 1419 const enabled = isCompatEnabled(key, context); 1420 if ( true && enabled) { 1421 warnDeprecation(key, context, loc, ...args); 1422 } 1423 return enabled; 1424} 1425function warnDeprecation(key, context, loc, ...args) { 1426 const val = getCompatValue(key, context); 1427 if (val === "suppress-warning") { 1428 return; 1429 } 1430 const { message, link } = deprecationData[key]; 1431 const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? ` 1432 Details: ${link}` : ``}`; 1433 const err = new SyntaxError(msg); 1434 err.code = key; 1435 if (loc) err.loc = loc; 1436 context.onWarn(err); 1437} 1438 1439function defaultOnError(error) { 1440 throw error; 1441} 1442function defaultOnWarn(msg) { 1443 true && console.warn(`[Vue warn] ${msg.message}`); 1444} 1445function createCompilerError(code, loc, messages, additionalMessage) { 1446 const msg = true ? (messages || errorMessages)[code] + (additionalMessage || ``) : 0; 1447 const error = new SyntaxError(String(msg)); 1448 error.code = code; 1449 error.loc = loc; 1450 return error; 1451} 1452const ErrorCodes = { 1453 "ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0, 1454 "0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT", 1455 "CDATA_IN_HTML_CONTENT": 1, 1456 "1": "CDATA_IN_HTML_CONTENT", 1457 "DUPLICATE_ATTRIBUTE": 2, 1458 "2": "DUPLICATE_ATTRIBUTE", 1459 "END_TAG_WITH_ATTRIBUTES": 3, 1460 "3": "END_TAG_WITH_ATTRIBUTES", 1461 "END_TAG_WITH_TRAILING_SOLIDUS": 4, 1462 "4": "END_TAG_WITH_TRAILING_SOLIDUS", 1463 "EOF_BEFORE_TAG_NAME": 5, 1464 "5": "EOF_BEFORE_TAG_NAME", 1465 "EOF_IN_CDATA": 6, 1466 "6": "EOF_IN_CDATA", 1467 "EOF_IN_COMMENT": 7, 1468 "7": "EOF_IN_COMMENT", 1469 "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8, 1470 "8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT", 1471 "EOF_IN_TAG": 9, 1472 "9": "EOF_IN_TAG", 1473 "INCORRECTLY_CLOSED_COMMENT": 10, 1474 "10": "INCORRECTLY_CLOSED_COMMENT", 1475 "INCORRECTLY_OPENED_COMMENT": 11, 1476 "11": "INCORRECTLY_OPENED_COMMENT", 1477 "INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12, 1478 "12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME", 1479 "MISSING_ATTRIBUTE_VALUE": 13, 1480 "13": "MISSING_ATTRIBUTE_VALUE", 1481 "MISSING_END_TAG_NAME": 14, 1482 "14": "MISSING_END_TAG_NAME", 1483 "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15, 1484 "15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES", 1485 "NESTED_COMMENT": 16, 1486 "16": "NESTED_COMMENT", 1487 "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17, 1488 "17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME", 1489 "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18, 1490 "18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE", 1491 "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19, 1492 "19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME", 1493 "UNEXPECTED_NULL_CHARACTER": 20, 1494 "20": "UNEXPECTED_NULL_CHARACTER", 1495 "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21, 1496 "21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME", 1497 "UNEXPECTED_SOLIDUS_IN_TAG": 22, 1498 "22": "UNEXPECTED_SOLIDUS_IN_TAG", 1499 "X_INVALID_END_TAG": 23, 1500 "23": "X_INVALID_END_TAG", 1501 "X_MISSING_END_TAG": 24, 1502 "24": "X_MISSING_END_TAG", 1503 "X_MISSING_INTERPOLATION_END": 25, 1504 "25": "X_MISSING_INTERPOLATION_END", 1505 "X_MISSING_DIRECTIVE_NAME": 26, 1506 "26": "X_MISSING_DIRECTIVE_NAME", 1507 "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27, 1508 "27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END", 1509 "X_V_IF_NO_EXPRESSION": 28, 1510 "28": "X_V_IF_NO_EXPRESSION", 1511 "X_V_IF_SAME_KEY": 29, 1512 "29": "X_V_IF_SAME_KEY", 1513 "X_V_ELSE_NO_ADJACENT_IF": 30, 1514 "30": "X_V_ELSE_NO_ADJACENT_IF", 1515 "X_V_FOR_NO_EXPRESSION": 31, 1516 "31": "X_V_FOR_NO_EXPRESSION", 1517 "X_V_FOR_MALFORMED_EXPRESSION": 32, 1518 "32": "X_V_FOR_MALFORMED_EXPRESSION", 1519 "X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33, 1520 "33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT", 1521 "X_V_BIND_NO_EXPRESSION": 34, 1522 "34": "X_V_BIND_NO_EXPRESSION", 1523 "X_V_ON_NO_EXPRESSION": 35, 1524 "35": "X_V_ON_NO_EXPRESSION", 1525 "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36, 1526 "36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET", 1527 "X_V_SLOT_MIXED_SLOT_USAGE": 37, 1528 "37": "X_V_SLOT_MIXED_SLOT_USAGE", 1529 "X_V_SLOT_DUPLICATE_SLOT_NAMES": 38, 1530 "38": "X_V_SLOT_DUPLICATE_SLOT_NAMES", 1531 "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39, 1532 "39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN", 1533 "X_V_SLOT_MISPLACED": 40, 1534 "40": "X_V_SLOT_MISPLACED", 1535 "X_V_MODEL_NO_EXPRESSION": 41, 1536 "41": "X_V_MODEL_NO_EXPRESSION", 1537 "X_V_MODEL_MALFORMED_EXPRESSION": 42, 1538 "42": "X_V_MODEL_MALFORMED_EXPRESSION", 1539 "X_V_MODEL_ON_SCOPE_VARIABLE": 43, 1540 "43": "X_V_MODEL_ON_SCOPE_VARIABLE", 1541 "X_V_MODEL_ON_PROPS": 44, 1542 "44": "X_V_MODEL_ON_PROPS", 1543 "X_INVALID_EXPRESSION": 45, 1544 "45": "X_INVALID_EXPRESSION", 1545 "X_KEEP_ALIVE_INVALID_CHILDREN": 46, 1546 "46": "X_KEEP_ALIVE_INVALID_CHILDREN", 1547 "X_PREFIX_ID_NOT_SUPPORTED": 47, 1548 "47": "X_PREFIX_ID_NOT_SUPPORTED", 1549 "X_MODULE_MODE_NOT_SUPPORTED": 48, 1550 "48": "X_MODULE_MODE_NOT_SUPPORTED", 1551 "X_CACHE_HANDLER_NOT_SUPPORTED": 49, 1552 "49": "X_CACHE_HANDLER_NOT_SUPPORTED", 1553 "X_SCOPE_ID_NOT_SUPPORTED": 50, 1554 "50": "X_SCOPE_ID_NOT_SUPPORTED", 1555 "X_VNODE_HOOKS": 51, 1556 "51": "X_VNODE_HOOKS", 1557 "X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 52, 1558 "52": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT", 1559 "__EXTEND_POINT__": 53, 1560 "53": "__EXTEND_POINT__" 1561}; 1562const errorMessages = { 1563 // parse errors 1564 [0]: "Illegal comment.", 1565 [1]: "CDATA section is allowed only in XML context.", 1566 [2]: "Duplicate attribute.", 1567 [3]: "End tag cannot have attributes.", 1568 [4]: "Illegal '/' in tags.", 1569 [5]: "Unexpected EOF in tag.", 1570 [6]: "Unexpected EOF in CDATA section.", 1571 [7]: "Unexpected EOF in comment.", 1572 [8]: "Unexpected EOF in script.", 1573 [9]: "Unexpected EOF in tag.", 1574 [10]: "Incorrectly closed comment.", 1575 [11]: "Incorrectly opened comment.", 1576 [12]: "Illegal tag name. Use '<' to print '<'.", 1577 [13]: "Attribute value was expected.", 1578 [14]: "End tag name was expected.", 1579 [15]: "Whitespace was expected.", 1580 [16]: "Unexpected '<!--' in comment.", 1581 [17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`, 1582 [18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).", 1583 [19]: "Attribute name cannot start with '='.", 1584 [21]: "'<?' is allowed only in XML context.", 1585 [20]: `Unexpected null character.`, 1586 [22]: "Illegal '/' in tags.", 1587 // Vue-specific parse errors 1588 [23]: "Invalid end tag.", 1589 [24]: "Element is missing end tag.", 1590 [25]: "Interpolation end sign was not found.", 1591 [27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.", 1592 [26]: "Legal directive name was expected.", 1593 // transform errors 1594 [28]: `v-if/v-else-if is missing expression.`, 1595 [29]: `v-if/else branches must use unique keys.`, 1596 [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`, 1597 [31]: `v-for is missing expression.`, 1598 [32]: `v-for has invalid expression.`, 1599 [33]: `<template v-for> key should be placed on the <template> tag.`, 1600 [34]: `v-bind is missing expression.`, 1601 [52]: `v-bind with same-name shorthand only allows static argument.`, 1602 [35]: `v-on is missing expression.`, 1603 [36]: `Unexpected custom directive on <slot> outlet.`, 1604 [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`, 1605 [38]: `Duplicate slot names found. `, 1606 [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`, 1607 [40]: `v-slot can only be used on components or <template> tags.`, 1608 [41]: `v-model is missing expression.`, 1609 [42]: `v-model value must be a valid JavaScript member expression.`, 1610 [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`, 1611 [44]: `v-model cannot be used on a prop, because local prop bindings are not writable. 1612Use a v-bind binding combined with a v-on listener that emits update:x event instead.`, 1613 [45]: `Error parsing JavaScript expression: `, 1614 [46]: `<KeepAlive> expects exactly one child component.`, 1615 [51]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`, 1616 // generic errors 1617 [47]: `"prefixIdentifiers" option is not supported in this build of compiler.`, 1618 [48]: `ES module mode is not supported in this build of compiler.`, 1619 [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`, 1620 [50]: `"scopeId" option is only supported in module mode.`, 1621 // just to fulfill types 1622 [53]: `` 1623}; 1624 1625function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) { 1626 { 1627 return; 1628 } 1629} 1630function isReferencedIdentifier(id, parent, parentStack) { 1631 { 1632 return false; 1633 } 1634} 1635function isInDestructureAssignment(parent, parentStack) { 1636 if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) { 1637 let i = parentStack.length; 1638 while (i--) { 1639 const p = parentStack[i]; 1640 if (p.type === "AssignmentExpression") { 1641 return true; 1642 } else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) { 1643 break; 1644 } 1645 } 1646 } 1647 return false; 1648} 1649function isInNewExpression(parentStack) { 1650 let i = parentStack.length; 1651 while (i--) { 1652 const p = parentStack[i]; 1653 if (p.type === "NewExpression") { 1654 return true; 1655 } else if (p.type !== "MemberExpression") { 1656 break; 1657 } 1658 } 1659 return false; 1660} 1661function walkFunctionParams(node, onIdent) { 1662 for (const p of node.params) { 1663 for (const id of extractIdentifiers(p)) { 1664 onIdent(id); 1665 } 1666 } 1667} 1668function walkBlockDeclarations(block, onIdent) { 1669 for (const stmt of block.body) { 1670 if (stmt.type === "VariableDeclaration") { 1671 if (stmt.declare) continue; 1672 for (const decl of stmt.declarations) { 1673 for (const id of extractIdentifiers(decl.id)) { 1674 onIdent(id); 1675 } 1676 } 1677 } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") { 1678 if (stmt.declare || !stmt.id) continue; 1679 onIdent(stmt.id); 1680 } else if (isForStatement(stmt)) { 1681 walkForStatement(stmt, true, onIdent); 1682 } 1683 } 1684} 1685function isForStatement(stmt) { 1686 return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement"; 1687} 1688function walkForStatement(stmt, isVar, onIdent) { 1689 const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left; 1690 if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) { 1691 for (const decl of variable.declarations) { 1692 for (const id of extractIdentifiers(decl.id)) { 1693 onIdent(id); 1694 } 1695 } 1696 } 1697} 1698function extractIdentifiers(param, nodes = []) { 1699 switch (param.type) { 1700 case "Identifier": 1701 nodes.push(param); 1702 break; 1703 case "MemberExpression": 1704 let object = param; 1705 while (object.type === "MemberExpression") { 1706 object = object.object; 1707 } 1708 nodes.push(object); 1709 break; 1710 case "ObjectPattern": 1711 for (const prop of param.properties) { 1712 if (prop.type === "RestElement") { 1713 extractIdentifiers(prop.argument, nodes); 1714 } else { 1715 extractIdentifiers(prop.value, nodes); 1716 } 1717 } 1718 break; 1719 case "ArrayPattern": 1720 param.elements.forEach((element) => { 1721 if (element) extractIdentifiers(element, nodes); 1722 }); 1723 break; 1724 case "RestElement": 1725 extractIdentifiers(param.argument, nodes); 1726 break; 1727 case "AssignmentPattern": 1728 extractIdentifiers(param.left, nodes); 1729 break; 1730 } 1731 return nodes; 1732} 1733const isFunctionType = (node) => { 1734 return /Function(?:Expression|Declaration)$|Method$/.test(node.type); 1735}; 1736const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed; 1737const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node; 1738const TS_NODE_TYPES = [ 1739 "TSAsExpression", 1740 // foo as number 1741 "TSTypeAssertion", 1742 // (<number>foo) 1743 "TSNonNullExpression", 1744 // foo! 1745 "TSInstantiationExpression", 1746 // foo<string> 1747 "TSSatisfiesExpression" 1748 // foo satisfies T 1749]; 1750function unwrapTSNode(node) { 1751 if (TS_NODE_TYPES.includes(node.type)) { 1752 return unwrapTSNode(node.expression); 1753 } else { 1754 return node; 1755 } 1756} 1757 1758const isStaticExp = (p) => p.type === 4 && p.isStatic; 1759function isCoreComponent(tag) { 1760 switch (tag) { 1761 case "Teleport": 1762 case "teleport": 1763 return TELEPORT; 1764 case "Suspense": 1765 case "suspense": 1766 return SUSPENSE; 1767 case "KeepAlive": 1768 case "keep-alive": 1769 return KEEP_ALIVE; 1770 case "BaseTransition": 1771 case "base-transition": 1772 return BASE_TRANSITION; 1773 } 1774} 1775const nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/; 1776const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name); 1777const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/; 1778const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/; 1779const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g; 1780const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source; 1781const isMemberExpressionBrowser = (exp) => { 1782 const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim()); 1783 let state = 0 /* inMemberExp */; 1784 let stateStack = []; 1785 let currentOpenBracketCount = 0; 1786 let currentOpenParensCount = 0; 1787 let currentStringType = null; 1788 for (let i = 0; i < path.length; i++) { 1789 const char = path.charAt(i); 1790 switch (state) { 1791 case 0 /* inMemberExp */: 1792 if (char === "[") { 1793 stateStack.push(state); 1794 state = 1 /* inBrackets */; 1795 currentOpenBracketCount++; 1796 } else if (char === "(") { 1797 stateStack.push(state); 1798 state = 2 /* inParens */; 1799 currentOpenParensCount++; 1800 } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) { 1801 return false; 1802 } 1803 break; 1804 case 1 /* inBrackets */: 1805 if (char === `'` || char === `"` || char === "`") { 1806 stateStack.push(state); 1807 state = 3 /* inString */; 1808 currentStringType = char; 1809 } else if (char === `[`) { 1810 currentOpenBracketCount++; 1811 } else if (char === `]`) { 1812 if (!--currentOpenBracketCount) { 1813 state = stateStack.pop(); 1814 } 1815 } 1816 break; 1817 case 2 /* inParens */: 1818 if (char === `'` || char === `"` || char === "`") { 1819 stateStack.push(state); 1820 state = 3 /* inString */; 1821 currentStringType = char; 1822 } else if (char === `(`) { 1823 currentOpenParensCount++; 1824 } else if (char === `)`) { 1825 if (i === path.length - 1) { 1826 return false; 1827 } 1828 if (!--currentOpenParensCount) { 1829 state = stateStack.pop(); 1830 } 1831 } 1832 break; 1833 case 3 /* inString */: 1834 if (char === currentStringType) { 1835 state = stateStack.pop(); 1836 currentStringType = null; 1837 } 1838 break; 1839 } 1840 } 1841 return !currentOpenBracketCount && !currentOpenParensCount; 1842}; 1843const isMemberExpressionNode = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP ; 1844const isMemberExpression = isMemberExpressionBrowser ; 1845const fnExpRE = /^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/; 1846const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp)); 1847const isFnExpressionNode = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP ; 1848const isFnExpression = isFnExpressionBrowser ; 1849function advancePositionWithClone(pos, source, numberOfCharacters = source.length) { 1850 return advancePositionWithMutation( 1851 { 1852 offset: pos.offset, 1853 line: pos.line, 1854 column: pos.column 1855 }, 1856 source, 1857 numberOfCharacters 1858 ); 1859} 1860function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) { 1861 let linesCount = 0; 1862 let lastNewLinePos = -1; 1863 for (let i = 0; i < numberOfCharacters; i++) { 1864 if (source.charCodeAt(i) === 10) { 1865 linesCount++; 1866 lastNewLinePos = i; 1867 } 1868 } 1869 pos.offset += numberOfCharacters; 1870 pos.line += linesCount; 1871 pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos; 1872 return pos; 1873} 1874function assert(condition, msg) { 1875 if (!condition) { 1876 throw new Error(msg || `unexpected compiler condition`); 1877 } 1878} 1879function findDir(node, name, allowEmpty = false) { 1880 for (let i = 0; i < node.props.length; i++) { 1881 const p = node.props[i]; 1882 if (p.type === 7 && (allowEmpty || p.exp) && ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(name) ? p.name === name : name.test(p.name))) { 1883 return p; 1884 } 1885 } 1886} 1887function findProp(node, name, dynamicOnly = false, allowEmpty = false) { 1888 for (let i = 0; i < node.props.length; i++) { 1889 const p = node.props[i]; 1890 if (p.type === 6) { 1891 if (dynamicOnly) continue; 1892 if (p.name === name && (p.value || allowEmpty)) { 1893 return p; 1894 } 1895 } else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) { 1896 return p; 1897 } 1898 } 1899} 1900function isStaticArgOf(arg, name) { 1901 return !!(arg && isStaticExp(arg) && arg.content === name); 1902} 1903function hasDynamicKeyVBind(node) { 1904 return node.props.some( 1905 (p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj" 1906 p.arg.type !== 4 || // v-bind:[_ctx.foo] 1907 !p.arg.isStatic) 1908 // v-bind:[foo] 1909 ); 1910} 1911function isText$1(node) { 1912 return node.type === 5 || node.type === 2; 1913} 1914function isVSlot(p) { 1915 return p.type === 7 && p.name === "slot"; 1916} 1917function isTemplateNode(node) { 1918 return node.type === 1 && node.tagType === 3; 1919} 1920function isSlotOutlet(node) { 1921 return node.type === 1 && node.tagType === 2; 1922} 1923const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]); 1924function getUnnormalizedProps(props, callPath = []) { 1925 if (props && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(props) && props.type === 14) { 1926 const callee = props.callee; 1927 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(callee) && propsHelperSet.has(callee)) { 1928 return getUnnormalizedProps( 1929 props.arguments[0], 1930 callPath.concat(props) 1931 ); 1932 } 1933 } 1934 return [props, callPath]; 1935} 1936function injectProp(node, prop, context) { 1937 let propsWithInjection; 1938 let props = node.type === 13 ? node.props : node.arguments[2]; 1939 let callPath = []; 1940 let parentCall; 1941 if (props && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(props) && props.type === 14) { 1942 const ret = getUnnormalizedProps(props); 1943 props = ret[0]; 1944 callPath = ret[1]; 1945 parentCall = callPath[callPath.length - 1]; 1946 } 1947 if (props == null || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(props)) { 1948 propsWithInjection = createObjectExpression([prop]); 1949 } else if (props.type === 14) { 1950 const first = props.arguments[0]; 1951 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(first) && first.type === 15) { 1952 if (!hasProp(prop, first)) { 1953 first.properties.unshift(prop); 1954 } 1955 } else { 1956 if (props.callee === TO_HANDLERS) { 1957 propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [ 1958 createObjectExpression([prop]), 1959 props 1960 ]); 1961 } else { 1962 props.arguments.unshift(createObjectExpression([prop])); 1963 } 1964 } 1965 !propsWithInjection && (propsWithInjection = props); 1966 } else if (props.type === 15) { 1967 if (!hasProp(prop, props)) { 1968 props.properties.unshift(prop); 1969 } 1970 propsWithInjection = props; 1971 } else { 1972 propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [ 1973 createObjectExpression([prop]), 1974 props 1975 ]); 1976 if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) { 1977 parentCall = callPath[callPath.length - 2]; 1978 } 1979 } 1980 if (node.type === 13) { 1981 if (parentCall) { 1982 parentCall.arguments[0] = propsWithInjection; 1983 } else { 1984 node.props = propsWithInjection; 1985 } 1986 } else { 1987 if (parentCall) { 1988 parentCall.arguments[0] = propsWithInjection; 1989 } else { 1990 node.arguments[2] = propsWithInjection; 1991 } 1992 } 1993} 1994function hasProp(prop, props) { 1995 let result = false; 1996 if (prop.key.type === 4) { 1997 const propKeyName = prop.key.content; 1998 result = props.properties.some( 1999 (p) => p.key.type === 4 && p.key.content === propKeyName 2000 ); 2001 } 2002 return result; 2003} 2004function toValidAssetId(name, type) { 2005 return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => { 2006 return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString(); 2007 })}`; 2008} 2009function hasScopeRef(node, ids) { 2010 if (!node || Object.keys(ids).length === 0) { 2011 return false; 2012 } 2013 switch (node.type) { 2014 case 1: 2015 for (let i = 0; i < node.props.length; i++) { 2016 const p = node.props[i]; 2017 if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) { 2018 return true; 2019 } 2020 } 2021 return node.children.some((c) => hasScopeRef(c, ids)); 2022 case 11: 2023 if (hasScopeRef(node.source, ids)) { 2024 return true; 2025 } 2026 return node.children.some((c) => hasScopeRef(c, ids)); 2027 case 9: 2028 return node.branches.some((b) => hasScopeRef(b, ids)); 2029 case 10: 2030 if (hasScopeRef(node.condition, ids)) { 2031 return true; 2032 } 2033 return node.children.some((c) => hasScopeRef(c, ids)); 2034 case 4: 2035 return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content]; 2036 case 8: 2037 return node.children.some((c) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(c) && hasScopeRef(c, ids)); 2038 case 5: 2039 case 12: 2040 return hasScopeRef(node.content, ids); 2041 case 2: 2042 case 3: 2043 case 20: 2044 return false; 2045 default: 2046 if (true) ; 2047 return false; 2048 } 2049} 2050function getMemoedVNodeCall(node) { 2051 if (node.type === 14 && node.callee === WITH_MEMO) { 2052 return node.arguments[1].returns; 2053 } else { 2054 return node; 2055 } 2056} 2057const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/; 2058 2059const defaultParserOptions = { 2060 parseMode: "base", 2061 ns: 0, 2062 delimiters: [`{{`, `}}`], 2063 getNamespace: () => 0, 2064 isVoidTag: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NO, 2065 isPreTag: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NO, 2066 isIgnoreNewlineTag: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NO, 2067 isCustomElement: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NO, 2068 onError: defaultOnError, 2069 onWarn: defaultOnWarn, 2070 comments: !!("development" !== "production"), 2071 prefixIdentifiers: false 2072}; 2073let currentOptions = defaultParserOptions; 2074let currentRoot = null; 2075let currentInput = ""; 2076let currentOpenTag = null; 2077let currentProp = null; 2078let currentAttrValue = ""; 2079let currentAttrStartIndex = -1; 2080let currentAttrEndIndex = -1; 2081let inPre = 0; 2082let inVPre = false; 2083let currentVPreBoundary = null; 2084const stack = []; 2085const tokenizer = new Tokenizer(stack, { 2086 onerr: emitError, 2087 ontext(start, end) { 2088 onText(getSlice(start, end), start, end); 2089 }, 2090 ontextentity(char, start, end) { 2091 onText(char, start, end); 2092 }, 2093 oninterpolation(start, end) { 2094 if (inVPre) { 2095 return onText(getSlice(start, end), start, end); 2096 } 2097 let innerStart = start + tokenizer.delimiterOpen.length; 2098 let innerEnd = end - tokenizer.delimiterClose.length; 2099 while (isWhitespace(currentInput.charCodeAt(innerStart))) { 2100 innerStart++; 2101 } 2102 while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) { 2103 innerEnd--; 2104 } 2105 let exp = getSlice(innerStart, innerEnd); 2106 if (exp.includes("&")) { 2107 { 2108 exp = currentOptions.decodeEntities(exp, false); 2109 } 2110 } 2111 addNode({ 2112 type: 5, 2113 content: createExp(exp, false, getLoc(innerStart, innerEnd)), 2114 loc: getLoc(start, end) 2115 }); 2116 }, 2117 onopentagname(start, end) { 2118 const name = getSlice(start, end); 2119 currentOpenTag = { 2120 type: 1, 2121 tag: name, 2122 ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns), 2123 tagType: 0, 2124 // will be refined on tag close 2125 props: [], 2126 children: [], 2127 loc: getLoc(start - 1, end), 2128 codegenNode: void 0 2129 }; 2130 }, 2131 onopentagend(end) { 2132 endOpenTag(end); 2133 }, 2134 onclosetag(start, end) { 2135 const name = getSlice(start, end); 2136 if (!currentOptions.isVoidTag(name)) { 2137 let found = false; 2138 for (let i = 0; i < stack.length; i++) { 2139 const e = stack[i]; 2140 if (e.tag.toLowerCase() === name.toLowerCase()) { 2141 found = true; 2142 if (i > 0) { 2143 emitError(24, stack[0].loc.start.offset); 2144 } 2145 for (let j = 0; j <= i; j++) { 2146 const el = stack.shift(); 2147 onCloseTag(el, end, j < i); 2148 } 2149 break; 2150 } 2151 } 2152 if (!found) { 2153 emitError(23, backTrack(start, 60)); 2154 } 2155 } 2156 }, 2157 onselfclosingtag(end) { 2158 const name = currentOpenTag.tag; 2159 currentOpenTag.isSelfClosing = true; 2160 endOpenTag(end); 2161 if (stack[0] && stack[0].tag === name) { 2162 onCloseTag(stack.shift(), end); 2163 } 2164 }, 2165 onattribname(start, end) { 2166 currentProp = { 2167 type: 6, 2168 name: getSlice(start, end), 2169 nameLoc: getLoc(start, end), 2170 value: void 0, 2171 loc: getLoc(start) 2172 }; 2173 }, 2174 ondirname(start, end) { 2175 const raw = getSlice(start, end); 2176 const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2); 2177 if (!inVPre && name === "") { 2178 emitError(26, start); 2179 } 2180 if (inVPre || name === "") { 2181 currentProp = { 2182 type: 6, 2183 name: raw, 2184 nameLoc: getLoc(start, end), 2185 value: void 0, 2186 loc: getLoc(start) 2187 }; 2188 } else { 2189 currentProp = { 2190 type: 7, 2191 name, 2192 rawName: raw, 2193 exp: void 0, 2194 arg: void 0, 2195 modifiers: raw === "." ? [createSimpleExpression("prop")] : [], 2196 loc: getLoc(start) 2197 }; 2198 if (name === "pre") { 2199 inVPre = tokenizer.inVPre = true; 2200 currentVPreBoundary = currentOpenTag; 2201 const props = currentOpenTag.props; 2202 for (let i = 0; i < props.length; i++) { 2203 if (props[i].type === 7) { 2204 props[i] = dirToAttr(props[i]); 2205 } 2206 } 2207 } 2208 } 2209 }, 2210 ondirarg(start, end) { 2211 if (start === end) return; 2212 const arg = getSlice(start, end); 2213 if (inVPre) { 2214 currentProp.name += arg; 2215 setLocEnd(currentProp.nameLoc, end); 2216 } else { 2217 const isStatic = arg[0] !== `[`; 2218 currentProp.arg = createExp( 2219 isStatic ? arg : arg.slice(1, -1), 2220 isStatic, 2221 getLoc(start, end), 2222 isStatic ? 3 : 0 2223 ); 2224 } 2225 }, 2226 ondirmodifier(start, end) { 2227 const mod = getSlice(start, end); 2228 if (inVPre) { 2229 currentProp.name += "." + mod; 2230 setLocEnd(currentProp.nameLoc, end); 2231 } else if (currentProp.name === "slot") { 2232 const arg = currentProp.arg; 2233 if (arg) { 2234 arg.content += "." + mod; 2235 setLocEnd(arg.loc, end); 2236 } 2237 } else { 2238 const exp = createSimpleExpression(mod, true, getLoc(start, end)); 2239 currentProp.modifiers.push(exp); 2240 } 2241 }, 2242 onattribdata(start, end) { 2243 currentAttrValue += getSlice(start, end); 2244 if (currentAttrStartIndex < 0) currentAttrStartIndex = start; 2245 currentAttrEndIndex = end; 2246 }, 2247 onattribentity(char, start, end) { 2248 currentAttrValue += char; 2249 if (currentAttrStartIndex < 0) currentAttrStartIndex = start; 2250 currentAttrEndIndex = end; 2251 }, 2252 onattribnameend(end) { 2253 const start = currentProp.loc.start.offset; 2254 const name = getSlice(start, end); 2255 if (currentProp.type === 7) { 2256 currentProp.rawName = name; 2257 } 2258 if (currentOpenTag.props.some( 2259 (p) => (p.type === 7 ? p.rawName : p.name) === name 2260 )) { 2261 emitError(2, start); 2262 } 2263 }, 2264 onattribend(quote, end) { 2265 if (currentOpenTag && currentProp) { 2266 setLocEnd(currentProp.loc, end); 2267 if (quote !== 0) { 2268 if (currentAttrValue.includes("&")) { 2269 currentAttrValue = currentOptions.decodeEntities( 2270 currentAttrValue, 2271 true 2272 ); 2273 } 2274 if (currentProp.type === 6) { 2275 if (currentProp.name === "class") { 2276 currentAttrValue = condense(currentAttrValue).trim(); 2277 } 2278 if (quote === 1 && !currentAttrValue) { 2279 emitError(13, end); 2280 } 2281 currentProp.value = { 2282 type: 2, 2283 content: currentAttrValue, 2284 loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1) 2285 }; 2286 if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") { 2287 tokenizer.enterRCDATA(toCharCodes(`</template`), 0); 2288 } 2289 } else { 2290 let expParseMode = 0 /* Normal */; 2291 currentProp.exp = createExp( 2292 currentAttrValue, 2293 false, 2294 getLoc(currentAttrStartIndex, currentAttrEndIndex), 2295 0, 2296 expParseMode 2297 ); 2298 if (currentProp.name === "for") { 2299 currentProp.forParseResult = parseForExpression(currentProp.exp); 2300 } 2301 let syncIndex = -1; 2302 if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.findIndex( 2303 (mod) => mod.content === "sync" 2304 )) > -1 && checkCompatEnabled( 2305 "COMPILER_V_BIND_SYNC", 2306 currentOptions, 2307 currentProp.loc, 2308 currentProp.rawName 2309 )) { 2310 currentProp.name = "model"; 2311 currentProp.modifiers.splice(syncIndex, 1); 2312 } 2313 } 2314 } 2315 if (currentProp.type !== 7 || currentProp.name !== "pre") { 2316 currentOpenTag.props.push(currentProp); 2317 } 2318 } 2319 currentAttrValue = ""; 2320 currentAttrStartIndex = currentAttrEndIndex = -1; 2321 }, 2322 oncomment(start, end) { 2323 if (currentOptions.comments) { 2324 addNode({ 2325 type: 3, 2326 content: getSlice(start, end), 2327 loc: getLoc(start - 4, end + 3) 2328 }); 2329 } 2330 }, 2331 onend() { 2332 const end = currentInput.length; 2333 if (( true) && tokenizer.state !== 1) { 2334 switch (tokenizer.state) { 2335 case 5: 2336 case 8: 2337 emitError(5, end); 2338 break; 2339 case 3: 2340 case 4: 2341 emitError( 2342 25, 2343 tokenizer.sectionStart 2344 ); 2345 break; 2346 case 28: 2347 if (tokenizer.currentSequence === Sequences.CdataEnd) { 2348 emitError(6, end); 2349 } else { 2350 emitError(7, end); 2351 } 2352 break; 2353 case 6: 2354 case 7: 2355 case 9: 2356 case 11: 2357 case 12: 2358 case 13: 2359 case 14: 2360 case 15: 2361 case 16: 2362 case 17: 2363 case 18: 2364 case 19: 2365 // " 2366 case 20: 2367 // ' 2368 case 21: 2369 emitError(9, end); 2370 break; 2371 } 2372 } 2373 for (let index = 0; index < stack.length; index++) { 2374 onCloseTag(stack[index], end - 1); 2375 emitError(24, stack[index].loc.start.offset); 2376 } 2377 }, 2378 oncdata(start, end) { 2379 if (stack[0].ns !== 0) { 2380 onText(getSlice(start, end), start, end); 2381 } else { 2382 emitError(1, start - 9); 2383 } 2384 }, 2385 onprocessinginstruction(start) { 2386 if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) { 2387 emitError( 2388 21, 2389 start - 1 2390 ); 2391 } 2392 } 2393}); 2394const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/; 2395const stripParensRE = /^\(|\)$/g; 2396function parseForExpression(input) { 2397 const loc = input.loc; 2398 const exp = input.content; 2399 const inMatch = exp.match(forAliasRE); 2400 if (!inMatch) return; 2401 const [, LHS, RHS] = inMatch; 2402 const createAliasExpression = (content, offset, asParam = false) => { 2403 const start = loc.start.offset + offset; 2404 const end = start + content.length; 2405 return createExp( 2406 content, 2407 false, 2408 getLoc(start, end), 2409 0, 2410 asParam ? 1 /* Params */ : 0 /* Normal */ 2411 ); 2412 }; 2413 const result = { 2414 source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)), 2415 value: void 0, 2416 key: void 0, 2417 index: void 0, 2418 finalized: false 2419 }; 2420 let valueContent = LHS.trim().replace(stripParensRE, "").trim(); 2421 const trimmedOffset = LHS.indexOf(valueContent); 2422 const iteratorMatch = valueContent.match(forIteratorRE); 2423 if (iteratorMatch) { 2424 valueContent = valueContent.replace(forIteratorRE, "").trim(); 2425 const keyContent = iteratorMatch[1].trim(); 2426 let keyOffset; 2427 if (keyContent) { 2428 keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length); 2429 result.key = createAliasExpression(keyContent, keyOffset, true); 2430 } 2431 if (iteratorMatch[2]) { 2432 const indexContent = iteratorMatch[2].trim(); 2433 if (indexContent) { 2434 result.index = createAliasExpression( 2435 indexContent, 2436 exp.indexOf( 2437 indexContent, 2438 result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length 2439 ), 2440 true 2441 ); 2442 } 2443 } 2444 } 2445 if (valueContent) { 2446 result.value = createAliasExpression(valueContent, trimmedOffset, true); 2447 } 2448 return result; 2449} 2450function getSlice(start, end) { 2451 return currentInput.slice(start, end); 2452} 2453function endOpenTag(end) { 2454 if (tokenizer.inSFCRoot) { 2455 currentOpenTag.innerLoc = getLoc(end + 1, end + 1); 2456 } 2457 addNode(currentOpenTag); 2458 const { tag, ns } = currentOpenTag; 2459 if (ns === 0 && currentOptions.isPreTag(tag)) { 2460 inPre++; 2461 } 2462 if (currentOptions.isVoidTag(tag)) { 2463 onCloseTag(currentOpenTag, end); 2464 } else { 2465 stack.unshift(currentOpenTag); 2466 if (ns === 1 || ns === 2) { 2467 tokenizer.inXML = true; 2468 } 2469 } 2470 currentOpenTag = null; 2471} 2472function onText(content, start, end) { 2473 { 2474 const tag = stack[0] && stack[0].tag; 2475 if (tag !== "script" && tag !== "style" && content.includes("&")) { 2476 content = currentOptions.decodeEntities(content, false); 2477 } 2478 } 2479 const parent = stack[0] || currentRoot; 2480 const lastNode = parent.children[parent.children.length - 1]; 2481 if (lastNode && lastNode.type === 2) { 2482 lastNode.content += content; 2483 setLocEnd(lastNode.loc, end); 2484 } else { 2485 parent.children.push({ 2486 type: 2, 2487 content, 2488 loc: getLoc(start, end) 2489 }); 2490 } 2491} 2492function onCloseTag(el, end, isImplied = false) { 2493 if (isImplied) { 2494 setLocEnd(el.loc, backTrack(end, 60)); 2495 } else { 2496 setLocEnd(el.loc, lookAhead(end, 62) + 1); 2497 } 2498 if (tokenizer.inSFCRoot) { 2499 if (el.children.length) { 2500 el.innerLoc.end = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, el.children[el.children.length - 1].loc.end); 2501 } else { 2502 el.innerLoc.end = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, el.innerLoc.start); 2503 } 2504 el.innerLoc.source = getSlice( 2505 el.innerLoc.start.offset, 2506 el.innerLoc.end.offset 2507 ); 2508 } 2509 const { tag, ns, children } = el; 2510 if (!inVPre) { 2511 if (tag === "slot") { 2512 el.tagType = 2; 2513 } else if (isFragmentTemplate(el)) { 2514 el.tagType = 3; 2515 } else if (isComponent(el)) { 2516 el.tagType = 1; 2517 } 2518 } 2519 if (!tokenizer.inRCDATA) { 2520 el.children = condenseWhitespace(children); 2521 } 2522 if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) { 2523 const first = children[0]; 2524 if (first && first.type === 2) { 2525 first.content = first.content.replace(/^\r?\n/, ""); 2526 } 2527 } 2528 if (ns === 0 && currentOptions.isPreTag(tag)) { 2529 inPre--; 2530 } 2531 if (currentVPreBoundary === el) { 2532 inVPre = tokenizer.inVPre = false; 2533 currentVPreBoundary = null; 2534 } 2535 if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) { 2536 tokenizer.inXML = false; 2537 } 2538 { 2539 const props = el.props; 2540 if ( true && isCompatEnabled( 2541 "COMPILER_V_IF_V_FOR_PRECEDENCE", 2542 currentOptions 2543 )) { 2544 let hasIf = false; 2545 let hasFor = false; 2546 for (let i = 0; i < props.length; i++) { 2547 const p = props[i]; 2548 if (p.type === 7) { 2549 if (p.name === "if") { 2550 hasIf = true; 2551 } else if (p.name === "for") { 2552 hasFor = true; 2553 } 2554 } 2555 if (hasIf && hasFor) { 2556 warnDeprecation( 2557 "COMPILER_V_IF_V_FOR_PRECEDENCE", 2558 currentOptions, 2559 el.loc 2560 ); 2561 break; 2562 } 2563 } 2564 } 2565 if (!tokenizer.inSFCRoot && isCompatEnabled( 2566 "COMPILER_NATIVE_TEMPLATE", 2567 currentOptions 2568 ) && el.tag === "template" && !isFragmentTemplate(el)) { 2569 true && warnDeprecation( 2570 "COMPILER_NATIVE_TEMPLATE", 2571 currentOptions, 2572 el.loc 2573 ); 2574 const parent = stack[0] || currentRoot; 2575 const index = parent.children.indexOf(el); 2576 parent.children.splice(index, 1, ...el.children); 2577 } 2578 const inlineTemplateProp = props.find( 2579 (p) => p.type === 6 && p.name === "inline-template" 2580 ); 2581 if (inlineTemplateProp && checkCompatEnabled( 2582 "COMPILER_INLINE_TEMPLATE", 2583 currentOptions, 2584 inlineTemplateProp.loc 2585 ) && el.children.length) { 2586 inlineTemplateProp.value = { 2587 type: 2, 2588 content: getSlice( 2589 el.children[0].loc.start.offset, 2590 el.children[el.children.length - 1].loc.end.offset 2591 ), 2592 loc: inlineTemplateProp.loc 2593 }; 2594 } 2595 } 2596} 2597function lookAhead(index, c) { 2598 let i = index; 2599 while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++; 2600 return i; 2601} 2602function backTrack(index, c) { 2603 let i = index; 2604 while (currentInput.charCodeAt(i) !== c && i >= 0) i--; 2605 return i; 2606} 2607const specialTemplateDir = /* @__PURE__ */ new Set(["if", "else", "else-if", "for", "slot"]); 2608function isFragmentTemplate({ tag, props }) { 2609 if (tag === "template") { 2610 for (let i = 0; i < props.length; i++) { 2611 if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) { 2612 return true; 2613 } 2614 } 2615 } 2616 return false; 2617} 2618function isComponent({ tag, props }) { 2619 if (currentOptions.isCustomElement(tag)) { 2620 return false; 2621 } 2622 if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) { 2623 return true; 2624 } 2625 for (let i = 0; i < props.length; i++) { 2626 const p = props[i]; 2627 if (p.type === 6) { 2628 if (p.name === "is" && p.value) { 2629 if (p.value.content.startsWith("vue:")) { 2630 return true; 2631 } else if (checkCompatEnabled( 2632 "COMPILER_IS_ON_ELEMENT", 2633 currentOptions, 2634 p.loc 2635 )) { 2636 return true; 2637 } 2638 } 2639 } else if (// :is on plain element - only treat as component in compat mode 2640 p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled( 2641 "COMPILER_IS_ON_ELEMENT", 2642 currentOptions, 2643 p.loc 2644 )) { 2645 return true; 2646 } 2647 } 2648 return false; 2649} 2650function isUpperCase(c) { 2651 return c > 64 && c < 91; 2652} 2653const windowsNewlineRE = /\r\n/g; 2654function condenseWhitespace(nodes, tag) { 2655 const shouldCondense = currentOptions.whitespace !== "preserve"; 2656 let removedWhitespace = false; 2657 for (let i = 0; i < nodes.length; i++) { 2658 const node = nodes[i]; 2659 if (node.type === 2) { 2660 if (!inPre) { 2661 if (isAllWhitespace(node.content)) { 2662 const prev = nodes[i - 1] && nodes[i - 1].type; 2663 const next = nodes[i + 1] && nodes[i + 1].type; 2664 if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) { 2665 removedWhitespace = true; 2666 nodes[i] = null; 2667 } else { 2668 node.content = " "; 2669 } 2670 } else if (shouldCondense) { 2671 node.content = condense(node.content); 2672 } 2673 } else { 2674 node.content = node.content.replace(windowsNewlineRE, "\n"); 2675 } 2676 } 2677 } 2678 return removedWhitespace ? nodes.filter(Boolean) : nodes; 2679} 2680function isAllWhitespace(str) { 2681 for (let i = 0; i < str.length; i++) { 2682 if (!isWhitespace(str.charCodeAt(i))) { 2683 return false; 2684 } 2685 } 2686 return true; 2687} 2688function hasNewlineChar(str) { 2689 for (let i = 0; i < str.length; i++) { 2690 const c = str.charCodeAt(i); 2691 if (c === 10 || c === 13) { 2692 return true; 2693 } 2694 } 2695 return false; 2696} 2697function condense(str) { 2698 let ret = ""; 2699 let prevCharIsWhitespace = false; 2700 for (let i = 0; i < str.length; i++) { 2701 if (isWhitespace(str.charCodeAt(i))) { 2702 if (!prevCharIsWhitespace) { 2703 ret += " "; 2704 prevCharIsWhitespace = true; 2705 } 2706 } else { 2707 ret += str[i]; 2708 prevCharIsWhitespace = false; 2709 } 2710 } 2711 return ret; 2712} 2713function addNode(node) { 2714 (stack[0] || currentRoot).children.push(node); 2715} 2716function getLoc(start, end) { 2717 return { 2718 start: tokenizer.getPos(start), 2719 // @ts-expect-error allow late attachment 2720 end: end == null ? end : tokenizer.getPos(end), 2721 // @ts-expect-error allow late attachment 2722 source: end == null ? end : getSlice(start, end) 2723 }; 2724} 2725function cloneLoc(loc) { 2726 return getLoc(loc.start.offset, loc.end.offset); 2727} 2728function setLocEnd(loc, end) { 2729 loc.end = tokenizer.getPos(end); 2730 loc.source = getSlice(loc.start.offset, end); 2731} 2732function dirToAttr(dir) { 2733 const attr = { 2734 type: 6, 2735 name: dir.rawName, 2736 nameLoc: getLoc( 2737 dir.loc.start.offset, 2738 dir.loc.start.offset + dir.rawName.length 2739 ), 2740 value: void 0, 2741 loc: dir.loc 2742 }; 2743 if (dir.exp) { 2744 const loc = dir.exp.loc; 2745 if (loc.end.offset < dir.loc.end.offset) { 2746 loc.start.offset--; 2747 loc.start.column--; 2748 loc.end.offset++; 2749 loc.end.column++; 2750 } 2751 attr.value = { 2752 type: 2, 2753 content: dir.exp.content, 2754 loc 2755 }; 2756 } 2757 return attr; 2758} 2759function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0 /* Normal */) { 2760 const exp = createSimpleExpression(content, isStatic, loc, constType); 2761 return exp; 2762} 2763function emitError(code, index, message) { 2764 currentOptions.onError( 2765 createCompilerError(code, getLoc(index, index), void 0, message) 2766 ); 2767} 2768function reset() { 2769 tokenizer.reset(); 2770 currentOpenTag = null; 2771 currentProp = null; 2772 currentAttrValue = ""; 2773 currentAttrStartIndex = -1; 2774 currentAttrEndIndex = -1; 2775 stack.length = 0; 2776} 2777function baseParse(input, options) { 2778 reset(); 2779 currentInput = input; 2780 currentOptions = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, defaultParserOptions); 2781 if (options) { 2782 let key; 2783 for (key in options) { 2784 if (options[key] != null) { 2785 currentOptions[key] = options[key]; 2786 } 2787 } 2788 } 2789 if (true) { 2790 if (!currentOptions.decodeEntities) { 2791 throw new Error( 2792 `[@vue/compiler-core] decodeEntities option is required in browser builds.` 2793 ); 2794 } 2795 } 2796 tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0; 2797 tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2; 2798 const delimiters = options && options.delimiters; 2799 if (delimiters) { 2800 tokenizer.delimiterOpen = toCharCodes(delimiters[0]); 2801 tokenizer.delimiterClose = toCharCodes(delimiters[1]); 2802 } 2803 const root = currentRoot = createRoot([], input); 2804 tokenizer.parse(currentInput); 2805 root.loc = getLoc(0, input.length); 2806 root.children = condenseWhitespace(root.children); 2807 currentRoot = null; 2808 return root; 2809} 2810 2811function cacheStatic(root, context) { 2812 walk( 2813 root, 2814 void 0, 2815 context, 2816 // Root node is unfortunately non-hoistable due to potential parent 2817 // fallthrough attributes. 2818 isSingleElementRoot(root, root.children[0]) 2819 ); 2820} 2821function isSingleElementRoot(root, child) { 2822 const { children } = root; 2823 return children.length === 1 && child.type === 1 && !isSlotOutlet(child); 2824} 2825function walk(node, parent, context, doNotHoistNode = false, inFor = false) { 2826 const { children } = node; 2827 const toCache = []; 2828 for (let i = 0; i < children.length; i++) { 2829 const child = children[i]; 2830 if (child.type === 1 && child.tagType === 0) { 2831 const constantType = doNotHoistNode ? 0 : getConstantType(child, context); 2832 if (constantType > 0) { 2833 if (constantType >= 2) { 2834 child.codegenNode.patchFlag = -1; 2835 toCache.push(child); 2836 continue; 2837 } 2838 } else { 2839 const codegenNode = child.codegenNode; 2840 if (codegenNode.type === 13) { 2841 const flag = codegenNode.patchFlag; 2842 if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) { 2843 const props = getNodeProps(child); 2844 if (props) { 2845 codegenNode.props = context.hoist(props); 2846 } 2847 } 2848 if (codegenNode.dynamicProps) { 2849 codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps); 2850 } 2851 } 2852 } 2853 } else if (child.type === 12) { 2854 const constantType = doNotHoistNode ? 0 : getConstantType(child, context); 2855 if (constantType >= 2) { 2856 toCache.push(child); 2857 continue; 2858 } 2859 } 2860 if (child.type === 1) { 2861 const isComponent = child.tagType === 1; 2862 if (isComponent) { 2863 context.scopes.vSlot++; 2864 } 2865 walk(child, node, context, false, inFor); 2866 if (isComponent) { 2867 context.scopes.vSlot--; 2868 } 2869 } else if (child.type === 11) { 2870 walk(child, node, context, child.children.length === 1, true); 2871 } else if (child.type === 9) { 2872 for (let i2 = 0; i2 < child.branches.length; i2++) { 2873 walk( 2874 child.branches[i2], 2875 node, 2876 context, 2877 child.branches[i2].children.length === 1, 2878 inFor 2879 ); 2880 } 2881 } 2882 } 2883 let cachedAsArray = false; 2884 if (toCache.length === children.length && node.type === 1) { 2885 if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(node.codegenNode.children)) { 2886 node.codegenNode.children = getCacheExpression( 2887 createArrayExpression(node.codegenNode.children) 2888 ); 2889 cachedAsArray = true; 2890 } else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(node.codegenNode.children) && node.codegenNode.children.type === 15) { 2891 const slot = getSlotNode(node.codegenNode, "default"); 2892 if (slot) { 2893 slot.returns = getCacheExpression( 2894 createArrayExpression(slot.returns) 2895 ); 2896 cachedAsArray = true; 2897 } 2898 } else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(parent.codegenNode.children) && parent.codegenNode.children.type === 15) { 2899 const slotName = findDir(node, "slot", true); 2900 const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg); 2901 if (slot) { 2902 slot.returns = getCacheExpression( 2903 createArrayExpression(slot.returns) 2904 ); 2905 cachedAsArray = true; 2906 } 2907 } 2908 } 2909 if (!cachedAsArray) { 2910 for (const child of toCache) { 2911 child.codegenNode = context.cache(child.codegenNode); 2912 } 2913 } 2914 function getCacheExpression(value) { 2915 const exp = context.cache(value); 2916 if (inFor && context.hmr) { 2917 exp.needArraySpread = true; 2918 } 2919 return exp; 2920 } 2921 function getSlotNode(node2, name) { 2922 if (node2.children && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(node2.children) && node2.children.type === 15) { 2923 const slot = node2.children.properties.find( 2924 (p) => p.key === name || p.key.content === name 2925 ); 2926 return slot && slot.value; 2927 } 2928 } 2929 if (toCache.length && context.transformHoist) { 2930 context.transformHoist(children, context, node); 2931 } 2932} 2933function getConstantType(node, context) { 2934 const { constantCache } = context; 2935 switch (node.type) { 2936 case 1: 2937 if (node.tagType !== 0) { 2938 return 0; 2939 } 2940 const cached = constantCache.get(node); 2941 if (cached !== void 0) { 2942 return cached; 2943 } 2944 const codegenNode = node.codegenNode; 2945 if (codegenNode.type !== 13) { 2946 return 0; 2947 } 2948 if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") { 2949 return 0; 2950 } 2951 if (codegenNode.patchFlag === void 0) { 2952 let returnType2 = 3; 2953 const generatedPropsType = getGeneratedPropsConstantType(node, context); 2954 if (generatedPropsType === 0) { 2955 constantCache.set(node, 0); 2956 return 0; 2957 } 2958 if (generatedPropsType < returnType2) { 2959 returnType2 = generatedPropsType; 2960 } 2961 for (let i = 0; i < node.children.length; i++) { 2962 const childType = getConstantType(node.children[i], context); 2963 if (childType === 0) { 2964 constantCache.set(node, 0); 2965 return 0; 2966 } 2967 if (childType < returnType2) { 2968 returnType2 = childType; 2969 } 2970 } 2971 if (returnType2 > 1) { 2972 for (let i = 0; i < node.props.length; i++) { 2973 const p = node.props[i]; 2974 if (p.type === 7 && p.name === "bind" && p.exp) { 2975 const expType = getConstantType(p.exp, context); 2976 if (expType === 0) { 2977 constantCache.set(node, 0); 2978 return 0; 2979 } 2980 if (expType < returnType2) { 2981 returnType2 = expType; 2982 } 2983 } 2984 } 2985 } 2986 if (codegenNode.isBlock) { 2987 for (let i = 0; i < node.props.length; i++) { 2988 const p = node.props[i]; 2989 if (p.type === 7) { 2990 constantCache.set(node, 0); 2991 return 0; 2992 } 2993 } 2994 context.removeHelper(OPEN_BLOCK); 2995 context.removeHelper( 2996 getVNodeBlockHelper(context.inSSR, codegenNode.isComponent) 2997 ); 2998 codegenNode.isBlock = false; 2999 context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent)); 3000 } 3001 constantCache.set(node, returnType2); 3002 return returnType2; 3003 } else { 3004 constantCache.set(node, 0); 3005 return 0; 3006 } 3007 case 2: 3008 case 3: 3009 return 3; 3010 case 9: 3011 case 11: 3012 case 10: 3013 return 0; 3014 case 5: 3015 case 12: 3016 return getConstantType(node.content, context); 3017 case 4: 3018 return node.constType; 3019 case 8: 3020 let returnType = 3; 3021 for (let i = 0; i < node.children.length; i++) { 3022 const child = node.children[i]; 3023 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(child) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(child)) { 3024 continue; 3025 } 3026 const childType = getConstantType(child, context); 3027 if (childType === 0) { 3028 return 0; 3029 } else if (childType < returnType) { 3030 returnType = childType; 3031 } 3032 } 3033 return returnType; 3034 case 20: 3035 return 2; 3036 default: 3037 if (true) ; 3038 return 0; 3039 } 3040} 3041const allowHoistedHelperSet = /* @__PURE__ */ new Set([ 3042 NORMALIZE_CLASS, 3043 NORMALIZE_STYLE, 3044 NORMALIZE_PROPS, 3045 GUARD_REACTIVE_PROPS 3046]); 3047function getConstantTypeOfHelperCall(value, context) { 3048 if (value.type === 14 && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(value.callee) && allowHoistedHelperSet.has(value.callee)) { 3049 const arg = value.arguments[0]; 3050 if (arg.type === 4) { 3051 return getConstantType(arg, context); 3052 } else if (arg.type === 14) { 3053 return getConstantTypeOfHelperCall(arg, context); 3054 } 3055 } 3056 return 0; 3057} 3058function getGeneratedPropsConstantType(node, context) { 3059 let returnType = 3; 3060 const props = getNodeProps(node); 3061 if (props && props.type === 15) { 3062 const { properties } = props; 3063 for (let i = 0; i < properties.length; i++) { 3064 const { key, value } = properties[i]; 3065 const keyType = getConstantType(key, context); 3066 if (keyType === 0) { 3067 return keyType; 3068 } 3069 if (keyType < returnType) { 3070 returnType = keyType; 3071 } 3072 let valueType; 3073 if (value.type === 4) { 3074 valueType = getConstantType(value, context); 3075 } else if (value.type === 14) { 3076 valueType = getConstantTypeOfHelperCall(value, context); 3077 } else { 3078 valueType = 0; 3079 } 3080 if (valueType === 0) { 3081 return valueType; 3082 } 3083 if (valueType < returnType) { 3084 returnType = valueType; 3085 } 3086 } 3087 } 3088 return returnType; 3089} 3090function getNodeProps(node) { 3091 const codegenNode = node.codegenNode; 3092 if (codegenNode.type === 13) { 3093 return codegenNode.props; 3094 } 3095} 3096 3097function createTransformContext(root, { 3098 filename = "", 3099 prefixIdentifiers = false, 3100 hoistStatic = false, 3101 hmr = false, 3102 cacheHandlers = false, 3103 nodeTransforms = [], 3104 directiveTransforms = {}, 3105 transformHoist = null, 3106 isBuiltInComponent = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP, 3107 isCustomElement = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP, 3108 expressionPlugins = [], 3109 scopeId = null, 3110 slotted = true, 3111 ssr = false, 3112 inSSR = false, 3113 ssrCssVars = ``, 3114 bindingMetadata = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.EMPTY_OBJ, 3115 inline = false, 3116 isTS = false, 3117 onError = defaultOnError, 3118 onWarn = defaultOnWarn, 3119 compatConfig 3120}) { 3121 const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/); 3122 const context = { 3123 // options 3124 filename, 3125 selfName: nameMatch && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.capitalize)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(nameMatch[1])), 3126 prefixIdentifiers, 3127 hoistStatic, 3128 hmr, 3129 cacheHandlers, 3130 nodeTransforms, 3131 directiveTransforms, 3132 transformHoist, 3133 isBuiltInComponent, 3134 isCustomElement, 3135 expressionPlugins, 3136 scopeId, 3137 slotted, 3138 ssr, 3139 inSSR, 3140 ssrCssVars, 3141 bindingMetadata, 3142 inline, 3143 isTS, 3144 onError, 3145 onWarn, 3146 compatConfig, 3147 // state 3148 root, 3149 helpers: /* @__PURE__ */ new Map(), 3150 components: /* @__PURE__ */ new Set(), 3151 directives: /* @__PURE__ */ new Set(), 3152 hoists: [], 3153 imports: [], 3154 cached: [], 3155 constantCache: /* @__PURE__ */ new WeakMap(), 3156 temps: 0, 3157 identifiers: /* @__PURE__ */ Object.create(null), 3158 scopes: { 3159 vFor: 0, 3160 vSlot: 0, 3161 vPre: 0, 3162 vOnce: 0 3163 }, 3164 parent: null, 3165 grandParent: null, 3166 currentNode: root, 3167 childIndex: 0, 3168 inVOnce: false, 3169 // methods 3170 helper(name) { 3171 const count = context.helpers.get(name) || 0; 3172 context.helpers.set(name, count + 1); 3173 return name; 3174 }, 3175 removeHelper(name) { 3176 const count = context.helpers.get(name); 3177 if (count) { 3178 const currentCount = count - 1; 3179 if (!currentCount) { 3180 context.helpers.delete(name); 3181 } else { 3182 context.helpers.set(name, currentCount); 3183 } 3184 } 3185 }, 3186 helperString(name) { 3187 return `_${helperNameMap[context.helper(name)]}`; 3188 }, 3189 replaceNode(node) { 3190 if (true) { 3191 if (!context.currentNode) { 3192 throw new Error(`Node being replaced is already removed.`); 3193 } 3194 if (!context.parent) { 3195 throw new Error(`Cannot replace root node.`); 3196 } 3197 } 3198 context.parent.children[context.childIndex] = context.currentNode = node; 3199 }, 3200 removeNode(node) { 3201 if ( true && !context.parent) { 3202 throw new Error(`Cannot remove root node.`); 3203 } 3204 const list = context.parent.children; 3205 const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1; 3206 if ( true && removalIndex < 0) { 3207 throw new Error(`node being removed is not a child of current parent`); 3208 } 3209 if (!node || node === context.currentNode) { 3210 context.currentNode = null; 3211 context.onNodeRemoved(); 3212 } else { 3213 if (context.childIndex > removalIndex) { 3214 context.childIndex--; 3215 context.onNodeRemoved(); 3216 } 3217 } 3218 context.parent.children.splice(removalIndex, 1); 3219 }, 3220 onNodeRemoved: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP, 3221 addIdentifiers(exp) { 3222 }, 3223 removeIdentifiers(exp) { 3224 }, 3225 hoist(exp) { 3226 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(exp)) exp = createSimpleExpression(exp); 3227 context.hoists.push(exp); 3228 const identifier = createSimpleExpression( 3229 `_hoisted_${context.hoists.length}`, 3230 false, 3231 exp.loc, 3232 2 3233 ); 3234 identifier.hoisted = exp; 3235 return identifier; 3236 }, 3237 cache(exp, isVNode = false, inVOnce = false) { 3238 const cacheExp = createCacheExpression( 3239 context.cached.length, 3240 exp, 3241 isVNode, 3242 inVOnce 3243 ); 3244 context.cached.push(cacheExp); 3245 return cacheExp; 3246 } 3247 }; 3248 { 3249 context.filters = /* @__PURE__ */ new Set(); 3250 } 3251 return context; 3252} 3253function transform(root, options) { 3254 const context = createTransformContext(root, options); 3255 traverseNode(root, context); 3256 if (options.hoistStatic) { 3257 cacheStatic(root, context); 3258 } 3259 if (!options.ssr) { 3260 createRootCodegen(root, context); 3261 } 3262 root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]); 3263 root.components = [...context.components]; 3264 root.directives = [...context.directives]; 3265 root.imports = context.imports; 3266 root.hoists = context.hoists; 3267 root.temps = context.temps; 3268 root.cached = context.cached; 3269 root.transformed = true; 3270 { 3271 root.filters = [...context.filters]; 3272 } 3273} 3274function createRootCodegen(root, context) { 3275 const { helper } = context; 3276 const { children } = root; 3277 if (children.length === 1) { 3278 const child = children[0]; 3279 if (isSingleElementRoot(root, child) && child.codegenNode) { 3280 const codegenNode = child.codegenNode; 3281 if (codegenNode.type === 13) { 3282 convertToBlock(codegenNode, context); 3283 } 3284 root.codegenNode = codegenNode; 3285 } else { 3286 root.codegenNode = child; 3287 } 3288 } else if (children.length > 1) { 3289 let patchFlag = 64; 3290 if ( true && children.filter((c) => c.type !== 3).length === 1) { 3291 patchFlag |= 2048; 3292 } 3293 root.codegenNode = createVNodeCall( 3294 context, 3295 helper(FRAGMENT), 3296 void 0, 3297 root.children, 3298 patchFlag, 3299 void 0, 3300 void 0, 3301 true, 3302 void 0, 3303 false 3304 ); 3305 } else ; 3306} 3307function traverseChildren(parent, context) { 3308 let i = 0; 3309 const nodeRemoved = () => { 3310 i--; 3311 }; 3312 for (; i < parent.children.length; i++) { 3313 const child = parent.children[i]; 3314 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(child)) continue; 3315 context.grandParent = context.parent; 3316 context.parent = parent; 3317 context.childIndex = i; 3318 context.onNodeRemoved = nodeRemoved; 3319 traverseNode(child, context); 3320 } 3321} 3322function traverseNode(node, context) { 3323 context.currentNode = node; 3324 const { nodeTransforms } = context; 3325 const exitFns = []; 3326 for (let i2 = 0; i2 < nodeTransforms.length; i2++) { 3327 const onExit = nodeTransforms[i2](node, context); 3328 if (onExit) { 3329 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(onExit)) { 3330 exitFns.push(...onExit); 3331 } else { 3332 exitFns.push(onExit); 3333 } 3334 } 3335 if (!context.currentNode) { 3336 return; 3337 } else { 3338 node = context.currentNode; 3339 } 3340 } 3341 switch (node.type) { 3342 case 3: 3343 if (!context.ssr) { 3344 context.helper(CREATE_COMMENT); 3345 } 3346 break; 3347 case 5: 3348 if (!context.ssr) { 3349 context.helper(TO_DISPLAY_STRING); 3350 } 3351 break; 3352 // for container types, further traverse downwards 3353 case 9: 3354 for (let i2 = 0; i2 < node.branches.length; i2++) { 3355 traverseNode(node.branches[i2], context); 3356 } 3357 break; 3358 case 10: 3359 case 11: 3360 case 1: 3361 case 0: 3362 traverseChildren(node, context); 3363 break; 3364 } 3365 context.currentNode = node; 3366 let i = exitFns.length; 3367 while (i--) { 3368 exitFns[i](); 3369 } 3370} 3371function createStructuralDirectiveTransform(name, fn) { 3372 const matches = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(name) ? (n) => n === name : (n) => name.test(n); 3373 return (node, context) => { 3374 if (node.type === 1) { 3375 const { props } = node; 3376 if (node.tagType === 3 && props.some(isVSlot)) { 3377 return; 3378 } 3379 const exitFns = []; 3380 for (let i = 0; i < props.length; i++) { 3381 const prop = props[i]; 3382 if (prop.type === 7 && matches(prop.name)) { 3383 props.splice(i, 1); 3384 i--; 3385 const onExit = fn(node, prop, context); 3386 if (onExit) exitFns.push(onExit); 3387 } 3388 } 3389 return exitFns; 3390 } 3391 }; 3392} 3393 3394const PURE_ANNOTATION = `/*@__PURE__*/`; 3395const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`; 3396function createCodegenContext(ast, { 3397 mode = "function", 3398 prefixIdentifiers = mode === "module", 3399 sourceMap = false, 3400 filename = `template.vue.html`, 3401 scopeId = null, 3402 optimizeImports = false, 3403 runtimeGlobalName = `Vue`, 3404 runtimeModuleName = `vue`, 3405 ssrRuntimeModuleName = "vue/server-renderer", 3406 ssr = false, 3407 isTS = false, 3408 inSSR = false 3409}) { 3410 const context = { 3411 mode, 3412 prefixIdentifiers, 3413 sourceMap, 3414 filename, 3415 scopeId, 3416 optimizeImports, 3417 runtimeGlobalName, 3418 runtimeModuleName, 3419 ssrRuntimeModuleName, 3420 ssr, 3421 isTS, 3422 inSSR, 3423 source: ast.source, 3424 code: ``, 3425 column: 1, 3426 line: 1, 3427 offset: 0, 3428 indentLevel: 0, 3429 pure: false, 3430 map: void 0, 3431 helper(key) { 3432 return `_${helperNameMap[key]}`; 3433 }, 3434 push(code, newlineIndex = -2 /* None */, node) { 3435 context.code += code; 3436 }, 3437 indent() { 3438 newline(++context.indentLevel); 3439 }, 3440 deindent(withoutNewLine = false) { 3441 if (withoutNewLine) { 3442 --context.indentLevel; 3443 } else { 3444 newline(--context.indentLevel); 3445 } 3446 }, 3447 newline() { 3448 newline(context.indentLevel); 3449 } 3450 }; 3451 function newline(n) { 3452 context.push("\n" + ` `.repeat(n), 0 /* Start */); 3453 } 3454 return context; 3455} 3456function generate(ast, options = {}) { 3457 const context = createCodegenContext(ast, options); 3458 if (options.onContextCreated) options.onContextCreated(context); 3459 const { 3460 mode, 3461 push, 3462 prefixIdentifiers, 3463 indent, 3464 deindent, 3465 newline, 3466 scopeId, 3467 ssr 3468 } = context; 3469 const helpers = Array.from(ast.helpers); 3470 const hasHelpers = helpers.length > 0; 3471 const useWithBlock = !prefixIdentifiers && mode !== "module"; 3472 const preambleContext = context; 3473 { 3474 genFunctionPreamble(ast, preambleContext); 3475 } 3476 const functionName = ssr ? `ssrRender` : `render`; 3477 const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"]; 3478 const signature = args.join(", "); 3479 { 3480 push(`function ${functionName}(${signature}) {`); 3481 } 3482 indent(); 3483 if (useWithBlock) { 3484 push(`with (_ctx) {`); 3485 indent(); 3486 if (hasHelpers) { 3487 push( 3488 `const { ${helpers.map(aliasHelper).join(", ")} } = _Vue 3489`, 3490 -1 /* End */ 3491 ); 3492 newline(); 3493 } 3494 } 3495 if (ast.components.length) { 3496 genAssets(ast.components, "component", context); 3497 if (ast.directives.length || ast.temps > 0) { 3498 newline(); 3499 } 3500 } 3501 if (ast.directives.length) { 3502 genAssets(ast.directives, "directive", context); 3503 if (ast.temps > 0) { 3504 newline(); 3505 } 3506 } 3507 if (ast.filters && ast.filters.length) { 3508 newline(); 3509 genAssets(ast.filters, "filter", context); 3510 newline(); 3511 } 3512 if (ast.temps > 0) { 3513 push(`let `); 3514 for (let i = 0; i < ast.temps; i++) { 3515 push(`${i > 0 ? `, ` : ``}_temp${i}`); 3516 } 3517 } 3518 if (ast.components.length || ast.directives.length || ast.temps) { 3519 push(` 3520`, 0 /* Start */); 3521 newline(); 3522 } 3523 if (!ssr) { 3524 push(`return `); 3525 } 3526 if (ast.codegenNode) { 3527 genNode(ast.codegenNode, context); 3528 } else { 3529 push(`null`); 3530 } 3531 if (useWithBlock) { 3532 deindent(); 3533 push(`}`); 3534 } 3535 deindent(); 3536 push(`}`); 3537 return { 3538 ast, 3539 code: context.code, 3540 preamble: ``, 3541 map: context.map ? context.map.toJSON() : void 0 3542 }; 3543} 3544function genFunctionPreamble(ast, context) { 3545 const { 3546 ssr, 3547 prefixIdentifiers, 3548 push, 3549 newline, 3550 runtimeModuleName, 3551 runtimeGlobalName, 3552 ssrRuntimeModuleName 3553 } = context; 3554 const VueBinding = runtimeGlobalName; 3555 const helpers = Array.from(ast.helpers); 3556 if (helpers.length > 0) { 3557 { 3558 push(`const _Vue = ${VueBinding} 3559`, -1 /* End */); 3560 if (ast.hoists.length) { 3561 const staticHelpers = [ 3562 CREATE_VNODE, 3563 CREATE_ELEMENT_VNODE, 3564 CREATE_COMMENT, 3565 CREATE_TEXT, 3566 CREATE_STATIC 3567 ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", "); 3568 push(`const { ${staticHelpers} } = _Vue 3569`, -1 /* End */); 3570 } 3571 } 3572 } 3573 genHoists(ast.hoists, context); 3574 newline(); 3575 push(`return `); 3576} 3577function genAssets(assets, type, { helper, push, newline, isTS }) { 3578 const resolver = helper( 3579 type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE 3580 ); 3581 for (let i = 0; i < assets.length; i++) { 3582 let id = assets[i]; 3583 const maybeSelfReference = id.endsWith("__self"); 3584 if (maybeSelfReference) { 3585 id = id.slice(0, -6); 3586 } 3587 push( 3588 `const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}` 3589 ); 3590 if (i < assets.length - 1) { 3591 newline(); 3592 } 3593 } 3594} 3595function genHoists(hoists, context) { 3596 if (!hoists.length) { 3597 return; 3598 } 3599 context.pure = true; 3600 const { push, newline } = context; 3601 newline(); 3602 for (let i = 0; i < hoists.length; i++) { 3603 const exp = hoists[i]; 3604 if (exp) { 3605 push(`const _hoisted_${i + 1} = `); 3606 genNode(exp, context); 3607 newline(); 3608 } 3609 } 3610 context.pure = false; 3611} 3612function isText(n) { 3613 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8; 3614} 3615function genNodeListAsArray(nodes, context) { 3616 const multilines = nodes.length > 3 || true && nodes.some((n) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(n) || !isText(n)); 3617 context.push(`[`); 3618 multilines && context.indent(); 3619 genNodeList(nodes, context, multilines); 3620 multilines && context.deindent(); 3621 context.push(`]`); 3622} 3623function genNodeList(nodes, context, multilines = false, comma = true) { 3624 const { push, newline } = context; 3625 for (let i = 0; i < nodes.length; i++) { 3626 const node = nodes[i]; 3627 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(node)) { 3628 push(node, -3 /* Unknown */); 3629 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(node)) { 3630 genNodeListAsArray(node, context); 3631 } else { 3632 genNode(node, context); 3633 } 3634 if (i < nodes.length - 1) { 3635 if (multilines) { 3636 comma && push(","); 3637 newline(); 3638 } else { 3639 comma && push(", "); 3640 } 3641 } 3642 } 3643} 3644function genNode(node, context) { 3645 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(node)) { 3646 context.push(node, -3 /* Unknown */); 3647 return; 3648 } 3649 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(node)) { 3650 context.push(context.helper(node)); 3651 return; 3652 } 3653 switch (node.type) { 3654 case 1: 3655 case 9: 3656 case 11: 3657 true && assert( 3658 node.codegenNode != null, 3659 `Codegen node is missing for element/if/for node. Apply appropriate transforms first.` 3660 ); 3661 genNode(node.codegenNode, context); 3662 break; 3663 case 2: 3664 genText(node, context); 3665 break; 3666 case 4: 3667 genExpression(node, context); 3668 break; 3669 case 5: 3670 genInterpolation(node, context); 3671 break; 3672 case 12: 3673 genNode(node.codegenNode, context); 3674 break; 3675 case 8: 3676 genCompoundExpression(node, context); 3677 break; 3678 case 3: 3679 genComment(node, context); 3680 break; 3681 case 13: 3682 genVNodeCall(node, context); 3683 break; 3684 case 14: 3685 genCallExpression(node, context); 3686 break; 3687 case 15: 3688 genObjectExpression(node, context); 3689 break; 3690 case 17: 3691 genArrayExpression(node, context); 3692 break; 3693 case 18: 3694 genFunctionExpression(node, context); 3695 break; 3696 case 19: 3697 genConditionalExpression(node, context); 3698 break; 3699 case 20: 3700 genCacheExpression(node, context); 3701 break; 3702 case 21: 3703 genNodeList(node.body, context, true, false); 3704 break; 3705 // SSR only types 3706 case 22: 3707 break; 3708 case 23: 3709 break; 3710 case 24: 3711 break; 3712 case 25: 3713 break; 3714 case 26: 3715 break; 3716 /* v8 ignore start */ 3717 case 10: 3718 break; 3719 default: 3720 if (true) { 3721 assert(false, `unhandled codegen node type: ${node.type}`); 3722 const exhaustiveCheck = node; 3723 return exhaustiveCheck; 3724 } 3725 } 3726} 3727function genText(node, context) { 3728 context.push(JSON.stringify(node.content), -3 /* Unknown */, node); 3729} 3730function genExpression(node, context) { 3731 const { content, isStatic } = node; 3732 context.push( 3733 isStatic ? JSON.stringify(content) : content, 3734 -3 /* Unknown */, 3735 node 3736 ); 3737} 3738function genInterpolation(node, context) { 3739 const { push, helper, pure } = context; 3740 if (pure) push(PURE_ANNOTATION); 3741 push(`${helper(TO_DISPLAY_STRING)}(`); 3742 genNode(node.content, context); 3743 push(`)`); 3744} 3745function genCompoundExpression(node, context) { 3746 for (let i = 0; i < node.children.length; i++) { 3747 const child = node.children[i]; 3748 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(child)) { 3749 context.push(child, -3 /* Unknown */); 3750 } else { 3751 genNode(child, context); 3752 } 3753 } 3754} 3755function genExpressionAsPropertyKey(node, context) { 3756 const { push } = context; 3757 if (node.type === 8) { 3758 push(`[`); 3759 genCompoundExpression(node, context); 3760 push(`]`); 3761 } else if (node.isStatic) { 3762 const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content); 3763 push(text, -2 /* None */, node); 3764 } else { 3765 push(`[${node.content}]`, -3 /* Unknown */, node); 3766 } 3767} 3768function genComment(node, context) { 3769 const { push, helper, pure } = context; 3770 if (pure) { 3771 push(PURE_ANNOTATION); 3772 } 3773 push( 3774 `${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, 3775 -3 /* Unknown */, 3776 node 3777 ); 3778} 3779function genVNodeCall(node, context) { 3780 const { push, helper, pure } = context; 3781 const { 3782 tag, 3783 props, 3784 children, 3785 patchFlag, 3786 dynamicProps, 3787 directives, 3788 isBlock, 3789 disableTracking, 3790 isComponent 3791 } = node; 3792 let patchFlagString; 3793 if (patchFlag) { 3794 if (true) { 3795 if (patchFlag < 0) { 3796 patchFlagString = patchFlag + ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[patchFlag]} */`; 3797 } else { 3798 const flagNames = Object.keys(_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => _vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[n]).join(`, `); 3799 patchFlagString = patchFlag + ` /* ${flagNames} */`; 3800 } 3801 } else {} 3802 } 3803 if (directives) { 3804 push(helper(WITH_DIRECTIVES) + `(`); 3805 } 3806 if (isBlock) { 3807 push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `); 3808 } 3809 if (pure) { 3810 push(PURE_ANNOTATION); 3811 } 3812 const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent); 3813 push(helper(callHelper) + `(`, -2 /* None */, node); 3814 genNodeList( 3815 genNullableArgs([tag, props, children, patchFlagString, dynamicProps]), 3816 context 3817 ); 3818 push(`)`); 3819 if (isBlock) { 3820 push(`)`); 3821 } 3822 if (directives) { 3823 push(`, `); 3824 genNode(directives, context); 3825 push(`)`); 3826 } 3827} 3828function genNullableArgs(args) { 3829 let i = args.length; 3830 while (i--) { 3831 if (args[i] != null) break; 3832 } 3833 return args.slice(0, i + 1).map((arg) => arg || `null`); 3834} 3835function genCallExpression(node, context) { 3836 const { push, helper, pure } = context; 3837 const callee = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(node.callee) ? node.callee : helper(node.callee); 3838 if (pure) { 3839 push(PURE_ANNOTATION); 3840 } 3841 push(callee + `(`, -2 /* None */, node); 3842 genNodeList(node.arguments, context); 3843 push(`)`); 3844} 3845function genObjectExpression(node, context) { 3846 const { push, indent, deindent, newline } = context; 3847 const { properties } = node; 3848 if (!properties.length) { 3849 push(`{}`, -2 /* None */, node); 3850 return; 3851 } 3852 const multilines = properties.length > 1 || true && properties.some((p) => p.value.type !== 4); 3853 push(multilines ? `{` : `{ `); 3854 multilines && indent(); 3855 for (let i = 0; i < properties.length; i++) { 3856 const { key, value } = properties[i]; 3857 genExpressionAsPropertyKey(key, context); 3858 push(`: `); 3859 genNode(value, context); 3860 if (i < properties.length - 1) { 3861 push(`,`); 3862 newline(); 3863 } 3864 } 3865 multilines && deindent(); 3866 push(multilines ? `}` : ` }`); 3867} 3868function genArrayExpression(node, context) { 3869 genNodeListAsArray(node.elements, context); 3870} 3871function genFunctionExpression(node, context) { 3872 const { push, indent, deindent } = context; 3873 const { params, returns, body, newline, isSlot } = node; 3874 if (isSlot) { 3875 push(`_${helperNameMap[WITH_CTX]}(`); 3876 } 3877 push(`(`, -2 /* None */, node); 3878 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(params)) { 3879 genNodeList(params, context); 3880 } else if (params) { 3881 genNode(params, context); 3882 } 3883 push(`) => `); 3884 if (newline || body) { 3885 push(`{`); 3886 indent(); 3887 } 3888 if (returns) { 3889 if (newline) { 3890 push(`return `); 3891 } 3892 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(returns)) { 3893 genNodeListAsArray(returns, context); 3894 } else { 3895 genNode(returns, context); 3896 } 3897 } else if (body) { 3898 genNode(body, context); 3899 } 3900 if (newline || body) { 3901 deindent(); 3902 push(`}`); 3903 } 3904 if (isSlot) { 3905 if (node.isNonScopedSlot) { 3906 push(`, undefined, true`); 3907 } 3908 push(`)`); 3909 } 3910} 3911function genConditionalExpression(node, context) { 3912 const { test, consequent, alternate, newline: needNewline } = node; 3913 const { push, indent, deindent, newline } = context; 3914 if (test.type === 4) { 3915 const needsParens = !isSimpleIdentifier(test.content); 3916 needsParens && push(`(`); 3917 genExpression(test, context); 3918 needsParens && push(`)`); 3919 } else { 3920 push(`(`); 3921 genNode(test, context); 3922 push(`)`); 3923 } 3924 needNewline && indent(); 3925 context.indentLevel++; 3926 needNewline || push(` `); 3927 push(`? `); 3928 genNode(consequent, context); 3929 context.indentLevel--; 3930 needNewline && newline(); 3931 needNewline || push(` `); 3932 push(`: `); 3933 const isNested = alternate.type === 19; 3934 if (!isNested) { 3935 context.indentLevel++; 3936 } 3937 genNode(alternate, context); 3938 if (!isNested) { 3939 context.indentLevel--; 3940 } 3941 needNewline && deindent( 3942 true 3943 /* without newline */ 3944 ); 3945} 3946function genCacheExpression(node, context) { 3947 const { push, helper, indent, deindent, newline } = context; 3948 const { needPauseTracking, needArraySpread } = node; 3949 if (needArraySpread) { 3950 push(`[...(`); 3951 } 3952 push(`_cache[${node.index}] || (`); 3953 if (needPauseTracking) { 3954 indent(); 3955 push(`${helper(SET_BLOCK_TRACKING)}(-1`); 3956 if (node.inVOnce) push(`, true`); 3957 push(`),`); 3958 newline(); 3959 push(`(`); 3960 } 3961 push(`_cache[${node.index}] = `); 3962 genNode(node.value, context); 3963 if (needPauseTracking) { 3964 push(`).cacheIndex = ${node.index},`); 3965 newline(); 3966 push(`${helper(SET_BLOCK_TRACKING)}(1),`); 3967 newline(); 3968 push(`_cache[${node.index}]`); 3969 deindent(); 3970 } 3971 push(`)`); 3972 if (needArraySpread) { 3973 push(`)]`); 3974 } 3975} 3976 3977const prohibitedKeywordRE = new RegExp( 3978 "\\b" + "arguments,await,break,case,catch,class,const,continue,debugger,default,delete,do,else,export,extends,finally,for,function,if,import,let,new,return,super,switch,throw,try,var,void,while,with,yield".split(",").join("\\b|\\b") + "\\b" 3979); 3980const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g; 3981function validateBrowserExpression(node, context, asParams = false, asRawStatements = false) { 3982 const exp = node.content; 3983 if (!exp.trim()) { 3984 return; 3985 } 3986 try { 3987 new Function( 3988 asRawStatements ? ` ${exp} ` : `return ${asParams ? `(${exp}) => {}` : `(${exp})`}` 3989 ); 3990 } catch (e) { 3991 let message = e.message; 3992 const keywordMatch = exp.replace(stripStringRE, "").match(prohibitedKeywordRE); 3993 if (keywordMatch) { 3994 message = `avoid using JavaScript keyword as property name: "${keywordMatch[0]}"`; 3995 } 3996 context.onError( 3997 createCompilerError( 3998 45, 3999 node.loc, 4000 void 0, 4001 message 4002 ) 4003 ); 4004 } 4005} 4006 4007const transformExpression = (node, context) => { 4008 if (node.type === 5) { 4009 node.content = processExpression( 4010 node.content, 4011 context 4012 ); 4013 } else if (node.type === 1) { 4014 const memo = findDir(node, "memo"); 4015 for (let i = 0; i < node.props.length; i++) { 4016 const dir = node.props[i]; 4017 if (dir.type === 7 && dir.name !== "for") { 4018 const exp = dir.exp; 4019 const arg = dir.arg; 4020 if (exp && exp.type === 4 && !(dir.name === "on" && arg) && // key has been processed in transformFor(vMemo + vFor) 4021 !(memo && arg && arg.type === 4 && arg.content === "key")) { 4022 dir.exp = processExpression( 4023 exp, 4024 context, 4025 // slot args must be processed as function params 4026 dir.name === "slot" 4027 ); 4028 } 4029 if (arg && arg.type === 4 && !arg.isStatic) { 4030 dir.arg = processExpression(arg, context); 4031 } 4032 } 4033 } 4034 } 4035}; 4036function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) { 4037 { 4038 if (true) { 4039 validateBrowserExpression(node, context, asParams, asRawStatements); 4040 } 4041 return node; 4042 } 4043} 4044function stringifyExpression(exp) { 4045 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(exp)) { 4046 return exp; 4047 } else if (exp.type === 4) { 4048 return exp.content; 4049 } else { 4050 return exp.children.map(stringifyExpression).join(""); 4051 } 4052} 4053 4054const transformIf = createStructuralDirectiveTransform( 4055 /^(if|else|else-if)$/, 4056 (node, dir, context) => { 4057 return processIf(node, dir, context, (ifNode, branch, isRoot) => { 4058 const siblings = context.parent.children; 4059 let i = siblings.indexOf(ifNode); 4060 let key = 0; 4061 while (i-- >= 0) { 4062 const sibling = siblings[i]; 4063 if (sibling && sibling.type === 9) { 4064 key += sibling.branches.length; 4065 } 4066 } 4067 return () => { 4068 if (isRoot) { 4069 ifNode.codegenNode = createCodegenNodeForBranch( 4070 branch, 4071 key, 4072 context 4073 ); 4074 } else { 4075 const parentCondition = getParentCondition(ifNode.codegenNode); 4076 parentCondition.alternate = createCodegenNodeForBranch( 4077 branch, 4078 key + ifNode.branches.length - 1, 4079 context 4080 ); 4081 } 4082 }; 4083 }); 4084 } 4085); 4086function processIf(node, dir, context, processCodegen) { 4087 if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) { 4088 const loc = dir.exp ? dir.exp.loc : node.loc; 4089 context.onError( 4090 createCompilerError(28, dir.loc) 4091 ); 4092 dir.exp = createSimpleExpression(`true`, false, loc); 4093 } 4094 if ( true && dir.exp) { 4095 validateBrowserExpression(dir.exp, context); 4096 } 4097 if (dir.name === "if") { 4098 const branch = createIfBranch(node, dir); 4099 const ifNode = { 4100 type: 9, 4101 loc: cloneLoc(node.loc), 4102 branches: [branch] 4103 }; 4104 context.replaceNode(ifNode); 4105 if (processCodegen) { 4106 return processCodegen(ifNode, branch, true); 4107 } 4108 } else { 4109 const siblings = context.parent.children; 4110 const comments = []; 4111 let i = siblings.indexOf(node); 4112 while (i-- >= -1) { 4113 const sibling = siblings[i]; 4114 if (sibling && sibling.type === 3) { 4115 context.removeNode(sibling); 4116 true && comments.unshift(sibling); 4117 continue; 4118 } 4119 if (sibling && sibling.type === 2 && !sibling.content.trim().length) { 4120 context.removeNode(sibling); 4121 continue; 4122 } 4123 if (sibling && sibling.type === 9) { 4124 if (dir.name === "else-if" && sibling.branches[sibling.branches.length - 1].condition === void 0) { 4125 context.onError( 4126 createCompilerError(30, node.loc) 4127 ); 4128 } 4129 context.removeNode(); 4130 const branch = createIfBranch(node, dir); 4131 if ( true && comments.length && // #3619 ignore comments if the v-if is direct child of <transition> 4132 !(context.parent && context.parent.type === 1 && (context.parent.tag === "transition" || context.parent.tag === "Transition"))) { 4133 branch.children = [...comments, ...branch.children]; 4134 } 4135 if (true) { 4136 const key = branch.userKey; 4137 if (key) { 4138 sibling.branches.forEach(({ userKey }) => { 4139 if (isSameKey(userKey, key)) { 4140 context.onError( 4141 createCompilerError( 4142 29, 4143 branch.userKey.loc 4144 ) 4145 ); 4146 } 4147 }); 4148 } 4149 } 4150 sibling.branches.push(branch); 4151 const onExit = processCodegen && processCodegen(sibling, branch, false); 4152 traverseNode(branch, context); 4153 if (onExit) onExit(); 4154 context.currentNode = null; 4155 } else { 4156 context.onError( 4157 createCompilerError(30, node.loc) 4158 ); 4159 } 4160 break; 4161 } 4162 } 4163} 4164function createIfBranch(node, dir) { 4165 const isTemplateIf = node.tagType === 3; 4166 return { 4167 type: 10, 4168 loc: node.loc, 4169 condition: dir.name === "else" ? void 0 : dir.exp, 4170 children: isTemplateIf && !findDir(node, "for") ? node.children : [node], 4171 userKey: findProp(node, `key`), 4172 isTemplateIf 4173 }; 4174} 4175function createCodegenNodeForBranch(branch, keyIndex, context) { 4176 if (branch.condition) { 4177 return createConditionalExpression( 4178 branch.condition, 4179 createChildrenCodegenNode(branch, keyIndex, context), 4180 // make sure to pass in asBlock: true so that the comment node call 4181 // closes the current block. 4182 createCallExpression(context.helper(CREATE_COMMENT), [ 4183 true ? '"v-if"' : 0, 4184 "true" 4185 ]) 4186 ); 4187 } else { 4188 return createChildrenCodegenNode(branch, keyIndex, context); 4189 } 4190} 4191function createChildrenCodegenNode(branch, keyIndex, context) { 4192 const { helper } = context; 4193 const keyProperty = createObjectProperty( 4194 `key`, 4195 createSimpleExpression( 4196 `${keyIndex}`, 4197 false, 4198 locStub, 4199 2 4200 ) 4201 ); 4202 const { children } = branch; 4203 const firstChild = children[0]; 4204 const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1; 4205 if (needFragmentWrapper) { 4206 if (children.length === 1 && firstChild.type === 11) { 4207 const vnodeCall = firstChild.codegenNode; 4208 injectProp(vnodeCall, keyProperty, context); 4209 return vnodeCall; 4210 } else { 4211 let patchFlag = 64; 4212 if ( true && !branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) { 4213 patchFlag |= 2048; 4214 } 4215 return createVNodeCall( 4216 context, 4217 helper(FRAGMENT), 4218 createObjectExpression([keyProperty]), 4219 children, 4220 patchFlag, 4221 void 0, 4222 void 0, 4223 true, 4224 false, 4225 false, 4226 branch.loc 4227 ); 4228 } 4229 } else { 4230 const ret = firstChild.codegenNode; 4231 const vnodeCall = getMemoedVNodeCall(ret); 4232 if (vnodeCall.type === 13) { 4233 convertToBlock(vnodeCall, context); 4234 } 4235 injectProp(vnodeCall, keyProperty, context); 4236 return ret; 4237 } 4238} 4239function isSameKey(a, b) { 4240 if (!a || a.type !== b.type) { 4241 return false; 4242 } 4243 if (a.type === 6) { 4244 if (a.value.content !== b.value.content) { 4245 return false; 4246 } 4247 } else { 4248 const exp = a.exp; 4249 const branchExp = b.exp; 4250 if (exp.type !== branchExp.type) { 4251 return false; 4252 } 4253 if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) { 4254 return false; 4255 } 4256 } 4257 return true; 4258} 4259function getParentCondition(node) { 4260 while (true) { 4261 if (node.type === 19) { 4262 if (node.alternate.type === 19) { 4263 node = node.alternate; 4264 } else { 4265 return node; 4266 } 4267 } else if (node.type === 20) { 4268 node = node.value; 4269 } 4270 } 4271} 4272 4273const transformBind = (dir, _node, context) => { 4274 const { modifiers, loc } = dir; 4275 const arg = dir.arg; 4276 let { exp } = dir; 4277 if (exp && exp.type === 4 && !exp.content.trim()) { 4278 { 4279 exp = void 0; 4280 } 4281 } 4282 if (!exp) { 4283 if (arg.type !== 4 || !arg.isStatic) { 4284 context.onError( 4285 createCompilerError( 4286 52, 4287 arg.loc 4288 ) 4289 ); 4290 return { 4291 props: [ 4292 createObjectProperty(arg, createSimpleExpression("", true, loc)) 4293 ] 4294 }; 4295 } 4296 transformBindShorthand(dir); 4297 exp = dir.exp; 4298 } 4299 if (arg.type !== 4) { 4300 arg.children.unshift(`(`); 4301 arg.children.push(`) || ""`); 4302 } else if (!arg.isStatic) { 4303 arg.content = `${arg.content} || ""`; 4304 } 4305 if (modifiers.some((mod) => mod.content === "camel")) { 4306 if (arg.type === 4) { 4307 if (arg.isStatic) { 4308 arg.content = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(arg.content); 4309 } else { 4310 arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`; 4311 } 4312 } else { 4313 arg.children.unshift(`${context.helperString(CAMELIZE)}(`); 4314 arg.children.push(`)`); 4315 } 4316 } 4317 if (!context.inSSR) { 4318 if (modifiers.some((mod) => mod.content === "prop")) { 4319 injectPrefix(arg, "."); 4320 } 4321 if (modifiers.some((mod) => mod.content === "attr")) { 4322 injectPrefix(arg, "^"); 4323 } 4324 } 4325 return { 4326 props: [createObjectProperty(arg, exp)] 4327 }; 4328}; 4329const transformBindShorthand = (dir, context) => { 4330 const arg = dir.arg; 4331 const propName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(arg.content); 4332 dir.exp = createSimpleExpression(propName, false, arg.loc); 4333}; 4334const injectPrefix = (arg, prefix) => { 4335 if (arg.type === 4) { 4336 if (arg.isStatic) { 4337 arg.content = prefix + arg.content; 4338 } else { 4339 arg.content = `\`${prefix}\${${arg.content}}\``; 4340 } 4341 } else { 4342 arg.children.unshift(`'${prefix}' + (`); 4343 arg.children.push(`)`); 4344 } 4345}; 4346 4347const transformFor = createStructuralDirectiveTransform( 4348 "for", 4349 (node, dir, context) => { 4350 const { helper, removeHelper } = context; 4351 return processFor(node, dir, context, (forNode) => { 4352 const renderExp = createCallExpression(helper(RENDER_LIST), [ 4353 forNode.source 4354 ]); 4355 const isTemplate = isTemplateNode(node); 4356 const memo = findDir(node, "memo"); 4357 const keyProp = findProp(node, `key`, false, true); 4358 const isDirKey = keyProp && keyProp.type === 7; 4359 if (isDirKey && !keyProp.exp) { 4360 transformBindShorthand(keyProp); 4361 } 4362 let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp); 4363 const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null; 4364 const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0; 4365 const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256; 4366 forNode.codegenNode = createVNodeCall( 4367 context, 4368 helper(FRAGMENT), 4369 void 0, 4370 renderExp, 4371 fragmentFlag, 4372 void 0, 4373 void 0, 4374 true, 4375 !isStableFragment, 4376 false, 4377 node.loc 4378 ); 4379 return () => { 4380 let childBlock; 4381 const { children } = forNode; 4382 if (( true) && isTemplate) { 4383 node.children.some((c) => { 4384 if (c.type === 1) { 4385 const key = findProp(c, "key"); 4386 if (key) { 4387 context.onError( 4388 createCompilerError( 4389 33, 4390 key.loc 4391 ) 4392 ); 4393 return true; 4394 } 4395 } 4396 }); 4397 } 4398 const needFragmentWrapper = children.length !== 1 || children[0].type !== 1; 4399 const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null; 4400 if (slotOutlet) { 4401 childBlock = slotOutlet.codegenNode; 4402 if (isTemplate && keyProperty) { 4403 injectProp(childBlock, keyProperty, context); 4404 } 4405 } else if (needFragmentWrapper) { 4406 childBlock = createVNodeCall( 4407 context, 4408 helper(FRAGMENT), 4409 keyProperty ? createObjectExpression([keyProperty]) : void 0, 4410 node.children, 4411 64, 4412 void 0, 4413 void 0, 4414 true, 4415 void 0, 4416 false 4417 ); 4418 } else { 4419 childBlock = children[0].codegenNode; 4420 if (isTemplate && keyProperty) { 4421 injectProp(childBlock, keyProperty, context); 4422 } 4423 if (childBlock.isBlock !== !isStableFragment) { 4424 if (childBlock.isBlock) { 4425 removeHelper(OPEN_BLOCK); 4426 removeHelper( 4427 getVNodeBlockHelper(context.inSSR, childBlock.isComponent) 4428 ); 4429 } else { 4430 removeHelper( 4431 getVNodeHelper(context.inSSR, childBlock.isComponent) 4432 ); 4433 } 4434 } 4435 childBlock.isBlock = !isStableFragment; 4436 if (childBlock.isBlock) { 4437 helper(OPEN_BLOCK); 4438 helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)); 4439 } else { 4440 helper(getVNodeHelper(context.inSSR, childBlock.isComponent)); 4441 } 4442 } 4443 if (memo) { 4444 const loop = createFunctionExpression( 4445 createForLoopParams(forNode.parseResult, [ 4446 createSimpleExpression(`_cached`) 4447 ]) 4448 ); 4449 loop.body = createBlockStatement([ 4450 createCompoundExpression([`const _memo = (`, memo.exp, `)`]), 4451 createCompoundExpression([ 4452 `if (_cached`, 4453 ...keyExp ? [` && _cached.key === `, keyExp] : [], 4454 ` && ${context.helperString( 4455 IS_MEMO_SAME 4456 )}(_cached, _memo)) return _cached` 4457 ]), 4458 createCompoundExpression([`const _item = `, childBlock]), 4459 createSimpleExpression(`_item.memo = _memo`), 4460 createSimpleExpression(`return _item`) 4461 ]); 4462 renderExp.arguments.push( 4463 loop, 4464 createSimpleExpression(`_cache`), 4465 createSimpleExpression(String(context.cached.length)) 4466 ); 4467 context.cached.push(null); 4468 } else { 4469 renderExp.arguments.push( 4470 createFunctionExpression( 4471 createForLoopParams(forNode.parseResult), 4472 childBlock, 4473 true 4474 ) 4475 ); 4476 } 4477 }; 4478 }); 4479 } 4480); 4481function processFor(node, dir, context, processCodegen) { 4482 if (!dir.exp) { 4483 context.onError( 4484 createCompilerError(31, dir.loc) 4485 ); 4486 return; 4487 } 4488 const parseResult = dir.forParseResult; 4489 if (!parseResult) { 4490 context.onError( 4491 createCompilerError(32, dir.loc) 4492 ); 4493 return; 4494 } 4495 finalizeForParseResult(parseResult, context); 4496 const { addIdentifiers, removeIdentifiers, scopes } = context; 4497 const { source, value, key, index } = parseResult; 4498 const forNode = { 4499 type: 11, 4500 loc: dir.loc, 4501 source, 4502 valueAlias: value, 4503 keyAlias: key, 4504 objectIndexAlias: index, 4505 parseResult, 4506 children: isTemplateNode(node) ? node.children : [node] 4507 }; 4508 context.replaceNode(forNode); 4509 scopes.vFor++; 4510 const onExit = processCodegen && processCodegen(forNode); 4511 return () => { 4512 scopes.vFor--; 4513 if (onExit) onExit(); 4514 }; 4515} 4516function finalizeForParseResult(result, context) { 4517 if (result.finalized) return; 4518 if (true) { 4519 validateBrowserExpression(result.source, context); 4520 if (result.key) { 4521 validateBrowserExpression( 4522 result.key, 4523 context, 4524 true 4525 ); 4526 } 4527 if (result.index) { 4528 validateBrowserExpression( 4529 result.index, 4530 context, 4531 true 4532 ); 4533 } 4534 if (result.value) { 4535 validateBrowserExpression( 4536 result.value, 4537 context, 4538 true 4539 ); 4540 } 4541 } 4542 result.finalized = true; 4543} 4544function createForLoopParams({ value, key, index }, memoArgs = []) { 4545 return createParamsList([value, key, index, ...memoArgs]); 4546} 4547function createParamsList(args) { 4548 let i = args.length; 4549 while (i--) { 4550 if (args[i]) break; 4551 } 4552 return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false)); 4553} 4554 4555const defaultFallback = createSimpleExpression(`undefined`, false); 4556const trackSlotScopes = (node, context) => { 4557 if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) { 4558 const vSlot = findDir(node, "slot"); 4559 if (vSlot) { 4560 vSlot.exp; 4561 context.scopes.vSlot++; 4562 return () => { 4563 context.scopes.vSlot--; 4564 }; 4565 } 4566 } 4567}; 4568const trackVForSlotScopes = (node, context) => { 4569 let vFor; 4570 if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) { 4571 const result = vFor.forParseResult; 4572 if (result) { 4573 finalizeForParseResult(result, context); 4574 const { value, key, index } = result; 4575 const { addIdentifiers, removeIdentifiers } = context; 4576 value && addIdentifiers(value); 4577 key && addIdentifiers(key); 4578 index && addIdentifiers(index); 4579 return () => { 4580 value && removeIdentifiers(value); 4581 key && removeIdentifiers(key); 4582 index && removeIdentifiers(index); 4583 }; 4584 } 4585 } 4586}; 4587const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression( 4588 props, 4589 children, 4590 false, 4591 true, 4592 children.length ? children[0].loc : loc 4593); 4594function buildSlots(node, context, buildSlotFn = buildClientSlotFn) { 4595 context.helper(WITH_CTX); 4596 const { children, loc } = node; 4597 const slotsProperties = []; 4598 const dynamicSlots = []; 4599 let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0; 4600 const onComponentSlot = findDir(node, "slot", true); 4601 if (onComponentSlot) { 4602 const { arg, exp } = onComponentSlot; 4603 if (arg && !isStaticExp(arg)) { 4604 hasDynamicSlots = true; 4605 } 4606 slotsProperties.push( 4607 createObjectProperty( 4608 arg || createSimpleExpression("default", true), 4609 buildSlotFn(exp, void 0, children, loc) 4610 ) 4611 ); 4612 } 4613 let hasTemplateSlots = false; 4614 let hasNamedDefaultSlot = false; 4615 const implicitDefaultChildren = []; 4616 const seenSlotNames = /* @__PURE__ */ new Set(); 4617 let conditionalBranchIndex = 0; 4618 for (let i = 0; i < children.length; i++) { 4619 const slotElement = children[i]; 4620 let slotDir; 4621 if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) { 4622 if (slotElement.type !== 3) { 4623 implicitDefaultChildren.push(slotElement); 4624 } 4625 continue; 4626 } 4627 if (onComponentSlot) { 4628 context.onError( 4629 createCompilerError(37, slotDir.loc) 4630 ); 4631 break; 4632 } 4633 hasTemplateSlots = true; 4634 const { children: slotChildren, loc: slotLoc } = slotElement; 4635 const { 4636 arg: slotName = createSimpleExpression(`default`, true), 4637 exp: slotProps, 4638 loc: dirLoc 4639 } = slotDir; 4640 let staticSlotName; 4641 if (isStaticExp(slotName)) { 4642 staticSlotName = slotName ? slotName.content : `default`; 4643 } else { 4644 hasDynamicSlots = true; 4645 } 4646 const vFor = findDir(slotElement, "for"); 4647 const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc); 4648 let vIf; 4649 let vElse; 4650 if (vIf = findDir(slotElement, "if")) { 4651 hasDynamicSlots = true; 4652 dynamicSlots.push( 4653 createConditionalExpression( 4654 vIf.exp, 4655 buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), 4656 defaultFallback 4657 ) 4658 ); 4659 } else if (vElse = findDir( 4660 slotElement, 4661 /^else(-if)?$/, 4662 true 4663 /* allowEmpty */ 4664 )) { 4665 let j = i; 4666 let prev; 4667 while (j--) { 4668 prev = children[j]; 4669 if (prev.type !== 3) { 4670 break; 4671 } 4672 } 4673 if (prev && isTemplateNode(prev) && findDir(prev, /^(else-)?if$/)) { 4674 let conditional = dynamicSlots[dynamicSlots.length - 1]; 4675 while (conditional.alternate.type === 19) { 4676 conditional = conditional.alternate; 4677 } 4678 conditional.alternate = vElse.exp ? createConditionalExpression( 4679 vElse.exp, 4680 buildDynamicSlot( 4681 slotName, 4682 slotFunction, 4683 conditionalBranchIndex++ 4684 ), 4685 defaultFallback 4686 ) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++); 4687 } else { 4688 context.onError( 4689 createCompilerError(30, vElse.loc) 4690 ); 4691 } 4692 } else if (vFor) { 4693 hasDynamicSlots = true; 4694 const parseResult = vFor.forParseResult; 4695 if (parseResult) { 4696 finalizeForParseResult(parseResult, context); 4697 dynamicSlots.push( 4698 createCallExpression(context.helper(RENDER_LIST), [ 4699 parseResult.source, 4700 createFunctionExpression( 4701 createForLoopParams(parseResult), 4702 buildDynamicSlot(slotName, slotFunction), 4703 true 4704 ) 4705 ]) 4706 ); 4707 } else { 4708 context.onError( 4709 createCompilerError( 4710 32, 4711 vFor.loc 4712 ) 4713 ); 4714 } 4715 } else { 4716 if (staticSlotName) { 4717 if (seenSlotNames.has(staticSlotName)) { 4718 context.onError( 4719 createCompilerError( 4720 38, 4721 dirLoc 4722 ) 4723 ); 4724 continue; 4725 } 4726 seenSlotNames.add(staticSlotName); 4727 if (staticSlotName === "default") { 4728 hasNamedDefaultSlot = true; 4729 } 4730 } 4731 slotsProperties.push(createObjectProperty(slotName, slotFunction)); 4732 } 4733 } 4734 if (!onComponentSlot) { 4735 const buildDefaultSlotProperty = (props, children2) => { 4736 const fn = buildSlotFn(props, void 0, children2, loc); 4737 if (context.compatConfig) { 4738 fn.isNonScopedSlot = true; 4739 } 4740 return createObjectProperty(`default`, fn); 4741 }; 4742 if (!hasTemplateSlots) { 4743 slotsProperties.push(buildDefaultSlotProperty(void 0, children)); 4744 } else if (implicitDefaultChildren.length && // #3766 4745 // with whitespace: 'preserve', whitespaces between slots will end up in 4746 // implicitDefaultChildren. Ignore if all implicit children are whitespaces. 4747 implicitDefaultChildren.some((node2) => isNonWhitespaceContent(node2))) { 4748 if (hasNamedDefaultSlot) { 4749 context.onError( 4750 createCompilerError( 4751 39, 4752 implicitDefaultChildren[0].loc 4753 ) 4754 ); 4755 } else { 4756 slotsProperties.push( 4757 buildDefaultSlotProperty(void 0, implicitDefaultChildren) 4758 ); 4759 } 4760 } 4761 } 4762 const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1; 4763 let slots = createObjectExpression( 4764 slotsProperties.concat( 4765 createObjectProperty( 4766 `_`, 4767 // 2 = compiled but dynamic = can skip normalization, but must run diff 4768 // 1 = compiled and static = can skip normalization AND diff as optimized 4769 createSimpleExpression( 4770 slotFlag + ( true ? ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.slotFlagsText[slotFlag]} */` : 0), 4771 false 4772 ) 4773 ) 4774 ), 4775 loc 4776 ); 4777 if (dynamicSlots.length) { 4778 slots = createCallExpression(context.helper(CREATE_SLOTS), [ 4779 slots, 4780 createArrayExpression(dynamicSlots) 4781 ]); 4782 } 4783 return { 4784 slots, 4785 hasDynamicSlots 4786 }; 4787} 4788function buildDynamicSlot(name, fn, index) { 4789 const props = [ 4790 createObjectProperty(`name`, name), 4791 createObjectProperty(`fn`, fn) 4792 ]; 4793 if (index != null) { 4794 props.push( 4795 createObjectProperty(`key`, createSimpleExpression(String(index), true)) 4796 ); 4797 } 4798 return createObjectExpression(props); 4799} 4800function hasForwardedSlots(children) { 4801 for (let i = 0; i < children.length; i++) { 4802 const child = children[i]; 4803 switch (child.type) { 4804 case 1: 4805 if (child.tagType === 2 || hasForwardedSlots(child.children)) { 4806 return true; 4807 } 4808 break; 4809 case 9: 4810 if (hasForwardedSlots(child.branches)) return true; 4811 break; 4812 case 10: 4813 case 11: 4814 if (hasForwardedSlots(child.children)) return true; 4815 break; 4816 } 4817 } 4818 return false; 4819} 4820function isNonWhitespaceContent(node) { 4821 if (node.type !== 2 && node.type !== 12) 4822 return true; 4823 return node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content); 4824} 4825 4826const directiveImportMap = /* @__PURE__ */ new WeakMap(); 4827const transformElement = (node, context) => { 4828 return function postTransformElement() { 4829 node = context.currentNode; 4830 if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) { 4831 return; 4832 } 4833 const { tag, props } = node; 4834 const isComponent = node.tagType === 1; 4835 let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`; 4836 const isDynamicComponent = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT; 4837 let vnodeProps; 4838 let vnodeChildren; 4839 let patchFlag = 0; 4840 let vnodeDynamicProps; 4841 let dynamicPropNames; 4842 let vnodeDirectives; 4843 let shouldUseBlock = ( 4844 // dynamic component may resolve to plain elements 4845 isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block 4846 // updates inside get proper isSVG flag at runtime. (#639, #643) 4847 // This is technically web-specific, but splitting the logic out of core 4848 // leads to too much unnecessary complexity. 4849 (tag === "svg" || tag === "foreignObject" || tag === "math") 4850 ); 4851 if (props.length > 0) { 4852 const propsBuildResult = buildProps( 4853 node, 4854 context, 4855 void 0, 4856 isComponent, 4857 isDynamicComponent 4858 ); 4859 vnodeProps = propsBuildResult.props; 4860 patchFlag = propsBuildResult.patchFlag; 4861 dynamicPropNames = propsBuildResult.dynamicPropNames; 4862 const directives = propsBuildResult.directives; 4863 vnodeDirectives = directives && directives.length ? createArrayExpression( 4864 directives.map((dir) => buildDirectiveArgs(dir, context)) 4865 ) : void 0; 4866 if (propsBuildResult.shouldUseBlock) { 4867 shouldUseBlock = true; 4868 } 4869 } 4870 if (node.children.length > 0) { 4871 if (vnodeTag === KEEP_ALIVE) { 4872 shouldUseBlock = true; 4873 patchFlag |= 1024; 4874 if ( true && node.children.length > 1) { 4875 context.onError( 4876 createCompilerError(46, { 4877 start: node.children[0].loc.start, 4878 end: node.children[node.children.length - 1].loc.end, 4879 source: "" 4880 }) 4881 ); 4882 } 4883 } 4884 const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling 4885 vnodeTag !== TELEPORT && // explained above. 4886 vnodeTag !== KEEP_ALIVE; 4887 if (shouldBuildAsSlots) { 4888 const { slots, hasDynamicSlots } = buildSlots(node, context); 4889 vnodeChildren = slots; 4890 if (hasDynamicSlots) { 4891 patchFlag |= 1024; 4892 } 4893 } else if (node.children.length === 1 && vnodeTag !== TELEPORT) { 4894 const child = node.children[0]; 4895 const type = child.type; 4896 const hasDynamicTextChild = type === 5 || type === 8; 4897 if (hasDynamicTextChild && getConstantType(child, context) === 0) { 4898 patchFlag |= 1; 4899 } 4900 if (hasDynamicTextChild || type === 2) { 4901 vnodeChildren = child; 4902 } else { 4903 vnodeChildren = node.children; 4904 } 4905 } else { 4906 vnodeChildren = node.children; 4907 } 4908 } 4909 if (dynamicPropNames && dynamicPropNames.length) { 4910 vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames); 4911 } 4912 node.codegenNode = createVNodeCall( 4913 context, 4914 vnodeTag, 4915 vnodeProps, 4916 vnodeChildren, 4917 patchFlag === 0 ? void 0 : patchFlag, 4918 vnodeDynamicProps, 4919 vnodeDirectives, 4920 !!shouldUseBlock, 4921 false, 4922 isComponent, 4923 node.loc 4924 ); 4925 }; 4926}; 4927function resolveComponentType(node, context, ssr = false) { 4928 let { tag } = node; 4929 const isExplicitDynamic = isComponentTag(tag); 4930 const isProp = findProp( 4931 node, 4932 "is", 4933 false, 4934 true 4935 /* allow empty */ 4936 ); 4937 if (isProp) { 4938 if (isExplicitDynamic || isCompatEnabled( 4939 "COMPILER_IS_ON_ELEMENT", 4940 context 4941 )) { 4942 let exp; 4943 if (isProp.type === 6) { 4944 exp = isProp.value && createSimpleExpression(isProp.value.content, true); 4945 } else { 4946 exp = isProp.exp; 4947 if (!exp) { 4948 exp = createSimpleExpression(`is`, false, isProp.arg.loc); 4949 } 4950 } 4951 if (exp) { 4952 return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [ 4953 exp 4954 ]); 4955 } 4956 } else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) { 4957 tag = isProp.value.content.slice(4); 4958 } 4959 } 4960 const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag); 4961 if (builtIn) { 4962 if (!ssr) context.helper(builtIn); 4963 return builtIn; 4964 } 4965 context.helper(RESOLVE_COMPONENT); 4966 context.components.add(tag); 4967 return toValidAssetId(tag, `component`); 4968} 4969function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) { 4970 const { tag, loc: elementLoc, children } = node; 4971 let properties = []; 4972 const mergeArgs = []; 4973 const runtimeDirectives = []; 4974 const hasChildren = children.length > 0; 4975 let shouldUseBlock = false; 4976 let patchFlag = 0; 4977 let hasRef = false; 4978 let hasClassBinding = false; 4979 let hasStyleBinding = false; 4980 let hasHydrationEventBinding = false; 4981 let hasDynamicKeys = false; 4982 let hasVnodeHook = false; 4983 const dynamicPropNames = []; 4984 const pushMergeArg = (arg) => { 4985 if (properties.length) { 4986 mergeArgs.push( 4987 createObjectExpression(dedupeProperties(properties), elementLoc) 4988 ); 4989 properties = []; 4990 } 4991 if (arg) mergeArgs.push(arg); 4992 }; 4993 const pushRefVForMarker = () => { 4994 if (context.scopes.vFor > 0) { 4995 properties.push( 4996 createObjectProperty( 4997 createSimpleExpression("ref_for", true), 4998 createSimpleExpression("true") 4999 ) 5000 ); 5001 } 5002 }; 5003 const analyzePatchFlag = ({ key, value }) => { 5004 if (isStaticExp(key)) { 5005 const name = key.content; 5006 const isEventHandler = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isOn)(name); 5007 if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click 5008 // dedicated fast path. 5009 name.toLowerCase() !== "onclick" && // omit v-model handlers 5010 name !== "onUpdate:modelValue" && // omit onVnodeXXX hooks 5011 !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isReservedProp)(name)) { 5012 hasHydrationEventBinding = true; 5013 } 5014 if (isEventHandler && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isReservedProp)(name)) { 5015 hasVnodeHook = true; 5016 } 5017 if (isEventHandler && value.type === 14) { 5018 value = value.arguments[0]; 5019 } 5020 if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) { 5021 return; 5022 } 5023 if (name === "ref") { 5024 hasRef = true; 5025 } else if (name === "class") { 5026 hasClassBinding = true; 5027 } else if (name === "style") { 5028 hasStyleBinding = true; 5029 } else if (name !== "key" && !dynamicPropNames.includes(name)) { 5030 dynamicPropNames.push(name); 5031 } 5032 if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) { 5033 dynamicPropNames.push(name); 5034 } 5035 } else { 5036 hasDynamicKeys = true; 5037 } 5038 }; 5039 for (let i = 0; i < props.length; i++) { 5040 const prop = props[i]; 5041 if (prop.type === 6) { 5042 const { loc, name, nameLoc, value } = prop; 5043 let isStatic = true; 5044 if (name === "ref") { 5045 hasRef = true; 5046 pushRefVForMarker(); 5047 } 5048 if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled( 5049 "COMPILER_IS_ON_ELEMENT", 5050 context 5051 ))) { 5052 continue; 5053 } 5054 properties.push( 5055 createObjectProperty( 5056 createSimpleExpression(name, true, nameLoc), 5057 createSimpleExpression( 5058 value ? value.content : "", 5059 isStatic, 5060 value ? value.loc : loc 5061 ) 5062 ) 5063 ); 5064 } else { 5065 const { name, arg, exp, loc, modifiers } = prop; 5066 const isVBind = name === "bind"; 5067 const isVOn = name === "on"; 5068 if (name === "slot") { 5069 if (!isComponent) { 5070 context.onError( 5071 createCompilerError(40, loc) 5072 ); 5073 } 5074 continue; 5075 } 5076 if (name === "once" || name === "memo") { 5077 continue; 5078 } 5079 if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled( 5080 "COMPILER_IS_ON_ELEMENT", 5081 context 5082 ))) { 5083 continue; 5084 } 5085 if (isVOn && ssr) { 5086 continue; 5087 } 5088 if ( 5089 // #938: elements with dynamic keys should be forced into blocks 5090 isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked 5091 // before children 5092 isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update") 5093 ) { 5094 shouldUseBlock = true; 5095 } 5096 if (isVBind && isStaticArgOf(arg, "ref")) { 5097 pushRefVForMarker(); 5098 } 5099 if (!arg && (isVBind || isVOn)) { 5100 hasDynamicKeys = true; 5101 if (exp) { 5102 if (isVBind) { 5103 pushRefVForMarker(); 5104 pushMergeArg(); 5105 { 5106 if (true) { 5107 const hasOverridableKeys = mergeArgs.some((arg2) => { 5108 if (arg2.type === 15) { 5109 return arg2.properties.some(({ key }) => { 5110 if (key.type !== 4 || !key.isStatic) { 5111 return true; 5112 } 5113 return key.content !== "class" && key.content !== "style" && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isOn)(key.content); 5114 }); 5115 } else { 5116 return true; 5117 } 5118 }); 5119 if (hasOverridableKeys) { 5120 checkCompatEnabled( 5121 "COMPILER_V_BIND_OBJECT_ORDER", 5122 context, 5123 loc 5124 ); 5125 } 5126 } 5127 if (isCompatEnabled( 5128 "COMPILER_V_BIND_OBJECT_ORDER", 5129 context 5130 )) { 5131 mergeArgs.unshift(exp); 5132 continue; 5133 } 5134 } 5135 mergeArgs.push(exp); 5136 } else { 5137 pushMergeArg({ 5138 type: 14, 5139 loc, 5140 callee: context.helper(TO_HANDLERS), 5141 arguments: isComponent ? [exp] : [exp, `true`] 5142 }); 5143 } 5144 } else { 5145 context.onError( 5146 createCompilerError( 5147 isVBind ? 34 : 35, 5148 loc 5149 ) 5150 ); 5151 } 5152 continue; 5153 } 5154 if (isVBind && modifiers.some((mod) => mod.content === "prop")) { 5155 patchFlag |= 32; 5156 } 5157 const directiveTransform = context.directiveTransforms[name]; 5158 if (directiveTransform) { 5159 const { props: props2, needRuntime } = directiveTransform(prop, node, context); 5160 !ssr && props2.forEach(analyzePatchFlag); 5161 if (isVOn && arg && !isStaticExp(arg)) { 5162 pushMergeArg(createObjectExpression(props2, elementLoc)); 5163 } else { 5164 properties.push(...props2); 5165 } 5166 if (needRuntime) { 5167 runtimeDirectives.push(prop); 5168 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(needRuntime)) { 5169 directiveImportMap.set(prop, needRuntime); 5170 } 5171 } 5172 } else if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isBuiltInDirective)(name)) { 5173 runtimeDirectives.push(prop); 5174 if (hasChildren) { 5175 shouldUseBlock = true; 5176 } 5177 } 5178 } 5179 } 5180 let propsExpression = void 0; 5181 if (mergeArgs.length) { 5182 pushMergeArg(); 5183 if (mergeArgs.length > 1) { 5184 propsExpression = createCallExpression( 5185 context.helper(MERGE_PROPS), 5186 mergeArgs, 5187 elementLoc 5188 ); 5189 } else { 5190 propsExpression = mergeArgs[0]; 5191 } 5192 } else if (properties.length) { 5193 propsExpression = createObjectExpression( 5194 dedupeProperties(properties), 5195 elementLoc 5196 ); 5197 } 5198 if (hasDynamicKeys) { 5199 patchFlag |= 16; 5200 } else { 5201 if (hasClassBinding && !isComponent) { 5202 patchFlag |= 2; 5203 } 5204 if (hasStyleBinding && !isComponent) { 5205 patchFlag |= 4; 5206 } 5207 if (dynamicPropNames.length) { 5208 patchFlag |= 8; 5209 } 5210 if (hasHydrationEventBinding) { 5211 patchFlag |= 32; 5212 } 5213 } 5214 if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) { 5215 patchFlag |= 512; 5216 } 5217 if (!context.inSSR && propsExpression) { 5218 switch (propsExpression.type) { 5219 case 15: 5220 let classKeyIndex = -1; 5221 let styleKeyIndex = -1; 5222 let hasDynamicKey = false; 5223 for (let i = 0; i < propsExpression.properties.length; i++) { 5224 const key = propsExpression.properties[i].key; 5225 if (isStaticExp(key)) { 5226 if (key.content === "class") { 5227 classKeyIndex = i; 5228 } else if (key.content === "style") { 5229 styleKeyIndex = i; 5230 } 5231 } else if (!key.isHandlerKey) { 5232 hasDynamicKey = true; 5233 } 5234 } 5235 const classProp = propsExpression.properties[classKeyIndex]; 5236 const styleProp = propsExpression.properties[styleKeyIndex]; 5237 if (!hasDynamicKey) { 5238 if (classProp && !isStaticExp(classProp.value)) { 5239 classProp.value = createCallExpression( 5240 context.helper(NORMALIZE_CLASS), 5241 [classProp.value] 5242 ); 5243 } 5244 if (styleProp && // the static style is compiled into an object, 5245 // so use `hasStyleBinding` to ensure that it is a dynamic style binding 5246 (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist, 5247 // v-bind:style with static literal object 5248 styleProp.value.type === 17)) { 5249 styleProp.value = createCallExpression( 5250 context.helper(NORMALIZE_STYLE), 5251 [styleProp.value] 5252 ); 5253 } 5254 } else { 5255 propsExpression = createCallExpression( 5256 context.helper(NORMALIZE_PROPS), 5257 [propsExpression] 5258 ); 5259 } 5260 break; 5261 case 14: 5262 break; 5263 default: 5264 propsExpression = createCallExpression( 5265 context.helper(NORMALIZE_PROPS), 5266 [ 5267 createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [ 5268 propsExpression 5269 ]) 5270 ] 5271 ); 5272 break; 5273 } 5274 } 5275 return { 5276 props: propsExpression, 5277 directives: runtimeDirectives, 5278 patchFlag, 5279 dynamicPropNames, 5280 shouldUseBlock 5281 }; 5282} 5283function dedupeProperties(properties) { 5284 const knownProps = /* @__PURE__ */ new Map(); 5285 const deduped = []; 5286 for (let i = 0; i < properties.length; i++) { 5287 const prop = properties[i]; 5288 if (prop.key.type === 8 || !prop.key.isStatic) { 5289 deduped.push(prop); 5290 continue; 5291 } 5292 const name = prop.key.content; 5293 const existing = knownProps.get(name); 5294 if (existing) { 5295 if (name === "style" || name === "class" || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isOn)(name)) { 5296 mergeAsArray(existing, prop); 5297 } 5298 } else { 5299 knownProps.set(name, prop); 5300 deduped.push(prop); 5301 } 5302 } 5303 return deduped; 5304} 5305function mergeAsArray(existing, incoming) { 5306 if (existing.value.type === 17) { 5307 existing.value.elements.push(incoming.value); 5308 } else { 5309 existing.value = createArrayExpression( 5310 [existing.value, incoming.value], 5311 existing.loc 5312 ); 5313 } 5314} 5315function buildDirectiveArgs(dir, context) { 5316 const dirArgs = []; 5317 const runtime = directiveImportMap.get(dir); 5318 if (runtime) { 5319 dirArgs.push(context.helperString(runtime)); 5320 } else { 5321 { 5322 context.helper(RESOLVE_DIRECTIVE); 5323 context.directives.add(dir.name); 5324 dirArgs.push(toValidAssetId(dir.name, `directive`)); 5325 } 5326 } 5327 const { loc } = dir; 5328 if (dir.exp) dirArgs.push(dir.exp); 5329 if (dir.arg) { 5330 if (!dir.exp) { 5331 dirArgs.push(`void 0`); 5332 } 5333 dirArgs.push(dir.arg); 5334 } 5335 if (Object.keys(dir.modifiers).length) { 5336 if (!dir.arg) { 5337 if (!dir.exp) { 5338 dirArgs.push(`void 0`); 5339 } 5340 dirArgs.push(`void 0`); 5341 } 5342 const trueExpression = createSimpleExpression(`true`, false, loc); 5343 dirArgs.push( 5344 createObjectExpression( 5345 dir.modifiers.map( 5346 (modifier) => createObjectProperty(modifier, trueExpression) 5347 ), 5348 loc 5349 ) 5350 ); 5351 } 5352 return createArrayExpression(dirArgs, dir.loc); 5353} 5354function stringifyDynamicPropNames(props) { 5355 let propsNamesString = `[`; 5356 for (let i = 0, l = props.length; i < l; i++) { 5357 propsNamesString += JSON.stringify(props[i]); 5358 if (i < l - 1) propsNamesString += ", "; 5359 } 5360 return propsNamesString + `]`; 5361} 5362function isComponentTag(tag) { 5363 return tag === "component" || tag === "Component"; 5364} 5365 5366const transformSlotOutlet = (node, context) => { 5367 if (isSlotOutlet(node)) { 5368 const { children, loc } = node; 5369 const { slotName, slotProps } = processSlotOutlet(node, context); 5370 const slotArgs = [ 5371 context.prefixIdentifiers ? `_ctx.$slots` : `$slots`, 5372 slotName, 5373 "{}", 5374 "undefined", 5375 "true" 5376 ]; 5377 let expectedLen = 2; 5378 if (slotProps) { 5379 slotArgs[2] = slotProps; 5380 expectedLen = 3; 5381 } 5382 if (children.length) { 5383 slotArgs[3] = createFunctionExpression([], children, false, false, loc); 5384 expectedLen = 4; 5385 } 5386 if (context.scopeId && !context.slotted) { 5387 expectedLen = 5; 5388 } 5389 slotArgs.splice(expectedLen); 5390 node.codegenNode = createCallExpression( 5391 context.helper(RENDER_SLOT), 5392 slotArgs, 5393 loc 5394 ); 5395 } 5396}; 5397function processSlotOutlet(node, context) { 5398 let slotName = `"default"`; 5399 let slotProps = void 0; 5400 const nonNameProps = []; 5401 for (let i = 0; i < node.props.length; i++) { 5402 const p = node.props[i]; 5403 if (p.type === 6) { 5404 if (p.value) { 5405 if (p.name === "name") { 5406 slotName = JSON.stringify(p.value.content); 5407 } else { 5408 p.name = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(p.name); 5409 nonNameProps.push(p); 5410 } 5411 } 5412 } else { 5413 if (p.name === "bind" && isStaticArgOf(p.arg, "name")) { 5414 if (p.exp) { 5415 slotName = p.exp; 5416 } else if (p.arg && p.arg.type === 4) { 5417 const name = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(p.arg.content); 5418 slotName = p.exp = createSimpleExpression(name, false, p.arg.loc); 5419 } 5420 } else { 5421 if (p.name === "bind" && p.arg && isStaticExp(p.arg)) { 5422 p.arg.content = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(p.arg.content); 5423 } 5424 nonNameProps.push(p); 5425 } 5426 } 5427 } 5428 if (nonNameProps.length > 0) { 5429 const { props, directives } = buildProps( 5430 node, 5431 context, 5432 nonNameProps, 5433 false, 5434 false 5435 ); 5436 slotProps = props; 5437 if (directives.length) { 5438 context.onError( 5439 createCompilerError( 5440 36, 5441 directives[0].loc 5442 ) 5443 ); 5444 } 5445 } 5446 return { 5447 slotName, 5448 slotProps 5449 }; 5450} 5451 5452const transformOn = (dir, node, context, augmentor) => { 5453 const { loc, modifiers, arg } = dir; 5454 if (!dir.exp && !modifiers.length) { 5455 context.onError(createCompilerError(35, loc)); 5456 } 5457 let eventName; 5458 if (arg.type === 4) { 5459 if (arg.isStatic) { 5460 let rawName = arg.content; 5461 if ( true && rawName.startsWith("vnode")) { 5462 context.onError(createCompilerError(51, arg.loc)); 5463 } 5464 if (rawName.startsWith("vue:")) { 5465 rawName = `vnode-${rawName.slice(4)}`; 5466 } 5467 const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? ( 5468 // for non-element and vnode lifecycle event listeners, auto convert 5469 // it to camelCase. See issue #2249 5470 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(rawName)) 5471 ) : ( 5472 // preserve case for plain element listeners that have uppercase 5473 // letters, as these may be custom elements' custom events 5474 `on:${rawName}` 5475 ); 5476 eventName = createSimpleExpression(eventString, true, arg.loc); 5477 } else { 5478 eventName = createCompoundExpression([ 5479 `${context.helperString(TO_HANDLER_KEY)}(`, 5480 arg, 5481 `)` 5482 ]); 5483 } 5484 } else { 5485 eventName = arg; 5486 eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`); 5487 eventName.children.push(`)`); 5488 } 5489 let exp = dir.exp; 5490 if (exp && !exp.content.trim()) { 5491 exp = void 0; 5492 } 5493 let shouldCache = context.cacheHandlers && !exp && !context.inVOnce; 5494 if (exp) { 5495 const isMemberExp = isMemberExpression(exp); 5496 const isInlineStatement = !(isMemberExp || isFnExpression(exp)); 5497 const hasMultipleStatements = exp.content.includes(`;`); 5498 if (true) { 5499 validateBrowserExpression( 5500 exp, 5501 context, 5502 false, 5503 hasMultipleStatements 5504 ); 5505 } 5506 if (isInlineStatement || shouldCache && isMemberExp) { 5507 exp = createCompoundExpression([ 5508 `${isInlineStatement ? `$event` : `${``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`, 5509 exp, 5510 hasMultipleStatements ? `}` : `)` 5511 ]); 5512 } 5513 } 5514 let ret = { 5515 props: [ 5516 createObjectProperty( 5517 eventName, 5518 exp || createSimpleExpression(`() => {}`, false, loc) 5519 ) 5520 ] 5521 }; 5522 if (augmentor) { 5523 ret = augmentor(ret); 5524 } 5525 if (shouldCache) { 5526 ret.props[0].value = context.cache(ret.props[0].value); 5527 } 5528 ret.props.forEach((p) => p.key.isHandlerKey = true); 5529 return ret; 5530}; 5531 5532const transformText = (node, context) => { 5533 if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) { 5534 return () => { 5535 const children = node.children; 5536 let currentContainer = void 0; 5537 let hasText = false; 5538 for (let i = 0; i < children.length; i++) { 5539 const child = children[i]; 5540 if (isText$1(child)) { 5541 hasText = true; 5542 for (let j = i + 1; j < children.length; j++) { 5543 const next = children[j]; 5544 if (isText$1(next)) { 5545 if (!currentContainer) { 5546 currentContainer = children[i] = createCompoundExpression( 5547 [child], 5548 child.loc 5549 ); 5550 } 5551 currentContainer.children.push(` + `, next); 5552 children.splice(j, 1); 5553 j--; 5554 } else { 5555 currentContainer = void 0; 5556 break; 5557 } 5558 } 5559 } 5560 } 5561 if (!hasText || // if this is a plain element with a single text child, leave it 5562 // as-is since the runtime has dedicated fast path for this by directly 5563 // setting textContent of the element. 5564 // for component root it's always normalized anyway. 5565 children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756 5566 // custom directives can potentially add DOM elements arbitrarily, 5567 // we need to avoid setting textContent of the element at runtime 5568 // to avoid accidentally overwriting the DOM elements added 5569 // by the user through custom directives. 5570 !node.props.find( 5571 (p) => p.type === 7 && !context.directiveTransforms[p.name] 5572 ) && // in compat mode, <template> tags with no special directives 5573 // will be rendered as a fragment so its children must be 5574 // converted into vnodes. 5575 !(node.tag === "template"))) { 5576 return; 5577 } 5578 for (let i = 0; i < children.length; i++) { 5579 const child = children[i]; 5580 if (isText$1(child) || child.type === 8) { 5581 const callArgs = []; 5582 if (child.type !== 2 || child.content !== " ") { 5583 callArgs.push(child); 5584 } 5585 if (!context.ssr && getConstantType(child, context) === 0) { 5586 callArgs.push( 5587 1 + ( true ? ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[1]} */` : 0) 5588 ); 5589 } 5590 children[i] = { 5591 type: 12, 5592 content: child, 5593 loc: child.loc, 5594 codegenNode: createCallExpression( 5595 context.helper(CREATE_TEXT), 5596 callArgs 5597 ) 5598 }; 5599 } 5600 } 5601 }; 5602 } 5603}; 5604 5605const seen$1 = /* @__PURE__ */ new WeakSet(); 5606const transformOnce = (node, context) => { 5607 if (node.type === 1 && findDir(node, "once", true)) { 5608 if (seen$1.has(node) || context.inVOnce || context.inSSR) { 5609 return; 5610 } 5611 seen$1.add(node); 5612 context.inVOnce = true; 5613 context.helper(SET_BLOCK_TRACKING); 5614 return () => { 5615 context.inVOnce = false; 5616 const cur = context.currentNode; 5617 if (cur.codegenNode) { 5618 cur.codegenNode = context.cache( 5619 cur.codegenNode, 5620 true, 5621 true 5622 ); 5623 } 5624 }; 5625 } 5626}; 5627 5628const transformModel = (dir, node, context) => { 5629 const { exp, arg } = dir; 5630 if (!exp) { 5631 context.onError( 5632 createCompilerError(41, dir.loc) 5633 ); 5634 return createTransformProps(); 5635 } 5636 const rawExp = exp.loc.source.trim(); 5637 const expString = exp.type === 4 ? exp.content : rawExp; 5638 const bindingType = context.bindingMetadata[rawExp]; 5639 if (bindingType === "props" || bindingType === "props-aliased") { 5640 context.onError(createCompilerError(44, exp.loc)); 5641 return createTransformProps(); 5642 } 5643 const maybeRef = false; 5644 if (!expString.trim() || !isMemberExpression(exp) && !maybeRef) { 5645 context.onError( 5646 createCompilerError(42, exp.loc) 5647 ); 5648 return createTransformProps(); 5649 } 5650 const propName = arg ? arg : createSimpleExpression("modelValue", true); 5651 const eventName = arg ? isStaticExp(arg) ? `onUpdate:${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`; 5652 let assignmentExp; 5653 const eventArg = context.isTS ? `($event: any)` : `$event`; 5654 { 5655 assignmentExp = createCompoundExpression([ 5656 `${eventArg} => ((`, 5657 exp, 5658 `) = $event)` 5659 ]); 5660 } 5661 const props = [ 5662 // modelValue: foo 5663 createObjectProperty(propName, dir.exp), 5664 // "onUpdate:modelValue": $event => (foo = $event) 5665 createObjectProperty(eventName, assignmentExp) 5666 ]; 5667 if (dir.modifiers.length && node.tagType === 1) { 5668 const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `); 5669 const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`; 5670 props.push( 5671 createObjectProperty( 5672 modifiersKey, 5673 createSimpleExpression( 5674 `{ ${modifiers} }`, 5675 false, 5676 dir.loc, 5677 2 5678 ) 5679 ) 5680 ); 5681 } 5682 return createTransformProps(props); 5683}; 5684function createTransformProps(props = []) { 5685 return { props }; 5686} 5687 5688const validDivisionCharRE = /[\w).+\-_$\]]/; 5689const transformFilter = (node, context) => { 5690 if (!isCompatEnabled("COMPILER_FILTERS", context)) { 5691 return; 5692 } 5693 if (node.type === 5) { 5694 rewriteFilter(node.content, context); 5695 } else if (node.type === 1) { 5696 node.props.forEach((prop) => { 5697 if (prop.type === 7 && prop.name !== "for" && prop.exp) { 5698 rewriteFilter(prop.exp, context); 5699 } 5700 }); 5701 } 5702}; 5703function rewriteFilter(node, context) { 5704 if (node.type === 4) { 5705 parseFilter(node, context); 5706 } else { 5707 for (let i = 0; i < node.children.length; i++) { 5708 const child = node.children[i]; 5709 if (typeof child !== "object") continue; 5710 if (child.type === 4) { 5711 parseFilter(child, context); 5712 } else if (child.type === 8) { 5713 rewriteFilter(node, context); 5714 } else if (child.type === 5) { 5715 rewriteFilter(child.content, context); 5716 } 5717 } 5718 } 5719} 5720function parseFilter(node, context) { 5721 const exp = node.content; 5722 let inSingle = false; 5723 let inDouble = false; 5724 let inTemplateString = false; 5725 let inRegex = false; 5726 let curly = 0; 5727 let square = 0; 5728 let paren = 0; 5729 let lastFilterIndex = 0; 5730 let c, prev, i, expression, filters = []; 5731 for (i = 0; i < exp.length; i++) { 5732 prev = c; 5733 c = exp.charCodeAt(i); 5734 if (inSingle) { 5735 if (c === 39 && prev !== 92) inSingle = false; 5736 } else if (inDouble) { 5737 if (c === 34 && prev !== 92) inDouble = false; 5738 } else if (inTemplateString) { 5739 if (c === 96 && prev !== 92) inTemplateString = false; 5740 } else if (inRegex) { 5741 if (c === 47 && prev !== 92) inRegex = false; 5742 } else if (c === 124 && // pipe 5743 exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) { 5744 if (expression === void 0) { 5745 lastFilterIndex = i + 1; 5746 expression = exp.slice(0, i).trim(); 5747 } else { 5748 pushFilter(); 5749 } 5750 } else { 5751 switch (c) { 5752 case 34: 5753 inDouble = true; 5754 break; 5755 // " 5756 case 39: 5757 inSingle = true; 5758 break; 5759 // ' 5760 case 96: 5761 inTemplateString = true; 5762 break; 5763 // ` 5764 case 40: 5765 paren++; 5766 break; 5767 // ( 5768 case 41: 5769 paren--; 5770 break; 5771 // ) 5772 case 91: 5773 square++; 5774 break; 5775 // [ 5776 case 93: 5777 square--; 5778 break; 5779 // ] 5780 case 123: 5781 curly++; 5782 break; 5783 // { 5784 case 125: 5785 curly--; 5786 break; 5787 } 5788 if (c === 47) { 5789 let j = i - 1; 5790 let p; 5791 for (; j >= 0; j--) { 5792 p = exp.charAt(j); 5793 if (p !== " ") break; 5794 } 5795 if (!p || !validDivisionCharRE.test(p)) { 5796 inRegex = true; 5797 } 5798 } 5799 } 5800 } 5801 if (expression === void 0) { 5802 expression = exp.slice(0, i).trim(); 5803 } else if (lastFilterIndex !== 0) { 5804 pushFilter(); 5805 } 5806 function pushFilter() { 5807 filters.push(exp.slice(lastFilterIndex, i).trim()); 5808 lastFilterIndex = i + 1; 5809 } 5810 if (filters.length) { 5811 true && warnDeprecation( 5812 "COMPILER_FILTERS", 5813 context, 5814 node.loc 5815 ); 5816 for (i = 0; i < filters.length; i++) { 5817 expression = wrapFilter(expression, filters[i], context); 5818 } 5819 node.content = expression; 5820 node.ast = void 0; 5821 } 5822} 5823function wrapFilter(exp, filter, context) { 5824 context.helper(RESOLVE_FILTER); 5825 const i = filter.indexOf("("); 5826 if (i < 0) { 5827 context.filters.add(filter); 5828 return `${toValidAssetId(filter, "filter")}(${exp})`; 5829 } else { 5830 const name = filter.slice(0, i); 5831 const args = filter.slice(i + 1); 5832 context.filters.add(name); 5833 return `${toValidAssetId(name, "filter")}(${exp}${args !== ")" ? "," + args : args}`; 5834 } 5835} 5836 5837const seen = /* @__PURE__ */ new WeakSet(); 5838const transformMemo = (node, context) => { 5839 if (node.type === 1) { 5840 const dir = findDir(node, "memo"); 5841 if (!dir || seen.has(node)) { 5842 return; 5843 } 5844 seen.add(node); 5845 return () => { 5846 const codegenNode = node.codegenNode || context.currentNode.codegenNode; 5847 if (codegenNode && codegenNode.type === 13) { 5848 if (node.tagType !== 1) { 5849 convertToBlock(codegenNode, context); 5850 } 5851 node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [ 5852 dir.exp, 5853 createFunctionExpression(void 0, codegenNode), 5854 `_cache`, 5855 String(context.cached.length) 5856 ]); 5857 context.cached.push(null); 5858 } 5859 }; 5860 } 5861}; 5862 5863function getBaseTransformPreset(prefixIdentifiers) { 5864 return [ 5865 [ 5866 transformOnce, 5867 transformIf, 5868 transformMemo, 5869 transformFor, 5870 ...[transformFilter] , 5871 ... true ? [transformExpression] : 0, 5872 transformSlotOutlet, 5873 transformElement, 5874 trackSlotScopes, 5875 transformText 5876 ], 5877 { 5878 on: transformOn, 5879 bind: transformBind, 5880 model: transformModel 5881 } 5882 ]; 5883} 5884function baseCompile(source, options = {}) { 5885 const onError = options.onError || defaultOnError; 5886 const isModuleMode = options.mode === "module"; 5887 { 5888 if (options.prefixIdentifiers === true) { 5889 onError(createCompilerError(47)); 5890 } else if (isModuleMode) { 5891 onError(createCompilerError(48)); 5892 } 5893 } 5894 const prefixIdentifiers = false; 5895 if (options.cacheHandlers) { 5896 onError(createCompilerError(49)); 5897 } 5898 if (options.scopeId && !isModuleMode) { 5899 onError(createCompilerError(50)); 5900 } 5901 const resolvedOptions = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, options, { 5902 prefixIdentifiers 5903 }); 5904 const ast = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(source) ? baseParse(source, resolvedOptions) : source; 5905 const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(); 5906 transform( 5907 ast, 5908 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, resolvedOptions, { 5909 nodeTransforms: [ 5910 ...nodeTransforms, 5911 ...options.nodeTransforms || [] 5912 // user transforms 5913 ], 5914 directiveTransforms: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)( 5915 {}, 5916 directiveTransforms, 5917 options.directiveTransforms || {} 5918 // user transforms 5919 ) 5920 }) 5921 ); 5922 return generate(ast, resolvedOptions); 5923} 5924 5925const BindingTypes = { 5926 "DATA": "data", 5927 "PROPS": "props", 5928 "PROPS_ALIASED": "props-aliased", 5929 "SETUP_LET": "setup-let", 5930 "SETUP_CONST": "setup-const", 5931 "SETUP_REACTIVE_CONST": "setup-reactive-const", 5932 "SETUP_MAYBE_REF": "setup-maybe-ref", 5933 "SETUP_REF": "setup-ref", 5934 "OPTIONS": "options", 5935 "LITERAL_CONST": "literal-const" 5936}; 5937 5938const noopDirectiveTransform = () => ({ props: [] }); 5939 5940 5941 5942 5943/***/ }), 5944
vendor: 42,187 bytes, lines 5945-6805
5945/***/ "./node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js": 5946/*!*************************************************************************!*\ 5947 !*** ./node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js ***! 5948 \*************************************************************************/ 5949/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 5950 5951"use strict"; 5952__webpack_require__.r(__webpack_exports__); 5953/* harmony export */ __webpack_require__.d(__webpack_exports__, { 5954/* harmony export */ BASE_TRANSITION: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.BASE_TRANSITION), 5955/* harmony export */ BindingTypes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.BindingTypes), 5956/* harmony export */ CAMELIZE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CAMELIZE), 5957/* harmony export */ CAPITALIZE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CAPITALIZE), 5958/* harmony export */ CREATE_BLOCK: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_BLOCK), 5959/* harmony export */ CREATE_COMMENT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_COMMENT), 5960/* harmony export */ CREATE_ELEMENT_BLOCK: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_ELEMENT_BLOCK), 5961/* harmony export */ CREATE_ELEMENT_VNODE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_ELEMENT_VNODE), 5962/* harmony export */ CREATE_SLOTS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_SLOTS), 5963/* harmony export */ CREATE_STATIC: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_STATIC), 5964/* harmony export */ CREATE_TEXT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_TEXT), 5965/* harmony export */ CREATE_VNODE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_VNODE), 5966/* harmony export */ CompilerDeprecationTypes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CompilerDeprecationTypes), 5967/* harmony export */ ConstantTypes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.ConstantTypes), 5968/* harmony export */ DOMDirectiveTransforms: () => (/* binding */ DOMDirectiveTransforms), 5969/* harmony export */ DOMErrorCodes: () => (/* binding */ DOMErrorCodes), 5970/* harmony export */ DOMErrorMessages: () => (/* binding */ DOMErrorMessages), 5971/* harmony export */ DOMNodeTransforms: () => (/* binding */ DOMNodeTransforms), 5972/* harmony export */ ElementTypes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.ElementTypes), 5973/* harmony export */ ErrorCodes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.ErrorCodes), 5974/* harmony export */ FRAGMENT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.FRAGMENT), 5975/* harmony export */ GUARD_REACTIVE_PROPS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.GUARD_REACTIVE_PROPS), 5976/* harmony export */ IS_MEMO_SAME: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.IS_MEMO_SAME), 5977/* harmony export */ IS_REF: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.IS_REF), 5978/* harmony export */ KEEP_ALIVE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.KEEP_ALIVE), 5979/* harmony export */ MERGE_PROPS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.MERGE_PROPS), 5980/* harmony export */ NORMALIZE_CLASS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NORMALIZE_CLASS), 5981/* harmony export */ NORMALIZE_PROPS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NORMALIZE_PROPS), 5982/* harmony export */ NORMALIZE_STYLE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NORMALIZE_STYLE), 5983/* harmony export */ Namespaces: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.Namespaces), 5984/* harmony export */ NodeTypes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NodeTypes), 5985/* harmony export */ OPEN_BLOCK: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.OPEN_BLOCK), 5986/* harmony export */ POP_SCOPE_ID: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.POP_SCOPE_ID), 5987/* harmony export */ PUSH_SCOPE_ID: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.PUSH_SCOPE_ID), 5988/* harmony export */ RENDER_LIST: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RENDER_LIST), 5989/* harmony export */ RENDER_SLOT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RENDER_SLOT), 5990/* harmony export */ RESOLVE_COMPONENT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_COMPONENT), 5991/* harmony export */ RESOLVE_DIRECTIVE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_DIRECTIVE), 5992/* harmony export */ RESOLVE_DYNAMIC_COMPONENT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_DYNAMIC_COMPONENT), 5993/* harmony export */ RESOLVE_FILTER: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_FILTER), 5994/* harmony export */ SET_BLOCK_TRACKING: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.SET_BLOCK_TRACKING), 5995/* harmony export */ SUSPENSE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.SUSPENSE), 5996/* harmony export */ TELEPORT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TELEPORT), 5997/* harmony export */ TO_DISPLAY_STRING: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_DISPLAY_STRING), 5998/* harmony export */ TO_HANDLERS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_HANDLERS), 5999/* harmony export */ TO_HANDLER_KEY: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_HANDLER_KEY), 6000/* harmony export */ TRANSITION: () => (/* binding */ TRANSITION), 6001/* harmony export */ TRANSITION_GROUP: () => (/* binding */ TRANSITION_GROUP), 6002/* harmony export */ TS_NODE_TYPES: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TS_NODE_TYPES), 6003/* harmony export */ UNREF: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.UNREF), 6004/* harmony export */ V_MODEL_CHECKBOX: () => (/* binding */ V_MODEL_CHECKBOX), 6005/* harmony export */ V_MODEL_DYNAMIC: () => (/* binding */ V_MODEL_DYNAMIC), 6006/* harmony export */ V_MODEL_RADIO: () => (/* binding */ V_MODEL_RADIO), 6007/* harmony export */ V_MODEL_SELECT: () => (/* binding */ V_MODEL_SELECT), 6008/* harmony export */ V_MODEL_TEXT: () => (/* binding */ V_MODEL_TEXT), 6009/* harmony export */ V_ON_WITH_KEYS: () => (/* binding */ V_ON_WITH_KEYS), 6010/* harmony export */ V_ON_WITH_MODIFIERS: () => (/* binding */ V_ON_WITH_MODIFIERS), 6011/* harmony export */ V_SHOW: () => (/* binding */ V_SHOW), 6012/* harmony export */ WITH_CTX: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.WITH_CTX), 6013/* harmony export */ WITH_DIRECTIVES: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.WITH_DIRECTIVES), 6014/* harmony export */ WITH_MEMO: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.WITH_MEMO), 6015/* harmony export */ advancePositionWithClone: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.advancePositionWithClone), 6016/* harmony export */ advancePositionWithMutation: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.advancePositionWithMutation), 6017/* harmony export */ assert: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.assert), 6018/* harmony export */ baseCompile: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseCompile), 6019/* harmony export */ baseParse: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseParse), 6020/* harmony export */ buildDirectiveArgs: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.buildDirectiveArgs), 6021/* harmony export */ buildProps: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.buildProps), 6022/* harmony export */ buildSlots: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.buildSlots), 6023/* harmony export */ checkCompatEnabled: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.checkCompatEnabled), 6024/* harmony export */ compile: () => (/* binding */ compile), 6025/* harmony export */ convertToBlock: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.convertToBlock), 6026/* harmony export */ createArrayExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createArrayExpression), 6027/* harmony export */ createAssignmentExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createAssignmentExpression), 6028/* harmony export */ createBlockStatement: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createBlockStatement), 6029/* harmony export */ createCacheExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCacheExpression), 6030/* harmony export */ createCallExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression), 6031/* harmony export */ createCompilerError: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompilerError), 6032/* harmony export */ createCompoundExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompoundExpression), 6033/* harmony export */ createConditionalExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createConditionalExpression), 6034/* harmony export */ createDOMCompilerError: () => (/* binding */ createDOMCompilerError), 6035/* harmony export */ createForLoopParams: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createForLoopParams), 6036/* harmony export */ createFunctionExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createFunctionExpression), 6037/* harmony export */ createIfStatement: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createIfStatement), 6038/* harmony export */ createInterpolation: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createInterpolation), 6039/* harmony export */ createObjectExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectExpression), 6040/* harmony export */ createObjectProperty: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty), 6041/* harmony export */ createReturnStatement: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createReturnStatement), 6042/* harmony export */ createRoot: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createRoot), 6043/* harmony export */ createSequenceExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSequenceExpression), 6044/* harmony export */ createSimpleExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression), 6045/* harmony export */ createStructuralDirectiveTransform: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createStructuralDirectiveTransform), 6046/* harmony export */ createTemplateLiteral: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createTemplateLiteral), 6047/* harmony export */ createTransformContext: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createTransformContext), 6048/* harmony export */ createVNodeCall: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createVNodeCall), 6049/* harmony export */ errorMessages: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.errorMessages), 6050/* harmony export */ extractIdentifiers: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.extractIdentifiers), 6051/* harmony export */ findDir: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findDir), 6052/* harmony export */ findProp: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findProp), 6053/* harmony export */ forAliasRE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.forAliasRE), 6054/* harmony export */ generate: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.generate), 6055/* harmony export */ generateCodeFrame: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.generateCodeFrame), 6056/* harmony export */ getBaseTransformPreset: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getBaseTransformPreset), 6057/* harmony export */ getConstantType: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getConstantType), 6058/* harmony export */ getMemoedVNodeCall: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getMemoedVNodeCall), 6059/* harmony export */ getVNodeBlockHelper: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getVNodeBlockHelper), 6060/* harmony export */ getVNodeHelper: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getVNodeHelper), 6061/* harmony export */ hasDynamicKeyVBind: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.hasDynamicKeyVBind), 6062/* harmony export */ hasScopeRef: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.hasScopeRef), 6063/* harmony export */ helperNameMap: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.helperNameMap), 6064/* harmony export */ injectProp: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.injectProp), 6065/* harmony export */ isCoreComponent: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isCoreComponent), 6066/* harmony export */ isFnExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isFnExpression), 6067/* harmony export */ isFnExpressionBrowser: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isFnExpressionBrowser), 6068/* harmony export */ isFnExpressionNode: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isFnExpressionNode), 6069/* harmony export */ isFunctionType: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isFunctionType), 6070/* harmony export */ isInDestructureAssignment: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isInDestructureAssignment), 6071/* harmony export */ isInNewExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isInNewExpression), 6072/* harmony export */ isMemberExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isMemberExpression), 6073/* harmony export */ isMemberExpressionBrowser: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isMemberExpressionBrowser), 6074/* harmony export */ isMemberExpressionNode: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isMemberExpressionNode), 6075/* harmony export */ isReferencedIdentifier: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isReferencedIdentifier), 6076/* harmony export */ isSimpleIdentifier: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isSimpleIdentifier), 6077/* harmony export */ isSlotOutlet: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isSlotOutlet), 6078/* harmony export */ isStaticArgOf: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticArgOf), 6079/* harmony export */ isStaticExp: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp), 6080/* harmony export */ isStaticProperty: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticProperty), 6081/* harmony export */ isStaticPropertyKey: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticPropertyKey), 6082/* harmony export */ isTemplateNode: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isTemplateNode), 6083/* harmony export */ isText: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isText), 6084/* harmony export */ isVSlot: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isVSlot), 6085/* harmony export */ locStub: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.locStub), 6086/* harmony export */ noopDirectiveTransform: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.noopDirectiveTransform), 6087/* harmony export */ parse: () => (/* binding */ parse), 6088/* harmony export */ parserOptions: () => (/* binding */ parserOptions), 6089/* harmony export */ processExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processExpression), 6090/* harmony export */ processFor: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processFor), 6091/* harmony export */ processIf: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processIf), 6092/* harmony export */ processSlotOutlet: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processSlotOutlet), 6093/* harmony export */ registerRuntimeHelpers: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeHelpers), 6094/* harmony export */ resolveComponentType: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.resolveComponentType), 6095/* harmony export */ stringifyExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.stringifyExpression), 6096/* harmony export */ toValidAssetId: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.toValidAssetId), 6097/* harmony export */ trackSlotScopes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.trackSlotScopes), 6098/* harmony export */ trackVForSlotScopes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.trackVForSlotScopes), 6099/* harmony export */ transform: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transform), 6100/* harmony export */ transformBind: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformBind), 6101/* harmony export */ transformElement: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformElement), 6102/* harmony export */ transformExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformExpression), 6103/* harmony export */ transformModel: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformModel), 6104/* harmony export */ transformOn: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformOn), 6105/* harmony export */ transformStyle: () => (/* binding */ transformStyle), 6106/* harmony export */ traverseNode: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.traverseNode), 6107/* harmony export */ unwrapTSNode: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.unwrapTSNode), 6108/* harmony export */ walkBlockDeclarations: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.walkBlockDeclarations), 6109/* harmony export */ walkFunctionParams: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.walkFunctionParams), 6110/* harmony export */ walkIdentifiers: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.walkIdentifiers), 6111/* harmony export */ warnDeprecation: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.warnDeprecation) 6112/* harmony export */ }); 6113/* harmony import */ var _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/compiler-core */ "./node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js"); 6114/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 6115/** 6116* @vue/compiler-dom v3.5.13 6117* (c) 2018-present Yuxi (Evan) You and Vue contributors 6118* @license MIT 6119**/ 6120 6121 6122 6123 6124const V_MODEL_RADIO = Symbol( true ? `vModelRadio` : 0); 6125const V_MODEL_CHECKBOX = Symbol( 6126 true ? `vModelCheckbox` : 0 6127); 6128const V_MODEL_TEXT = Symbol( true ? `vModelText` : 0); 6129const V_MODEL_SELECT = Symbol( 6130 true ? `vModelSelect` : 0 6131); 6132const V_MODEL_DYNAMIC = Symbol( 6133 true ? `vModelDynamic` : 0 6134); 6135const V_ON_WITH_MODIFIERS = Symbol( 6136 true ? `vOnModifiersGuard` : 0 6137); 6138const V_ON_WITH_KEYS = Symbol( 6139 true ? `vOnKeysGuard` : 0 6140); 6141const V_SHOW = Symbol( true ? `vShow` : 0); 6142const TRANSITION = Symbol( true ? `Transition` : 0); 6143const TRANSITION_GROUP = Symbol( 6144 true ? `TransitionGroup` : 0 6145); 6146(0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeHelpers)({ 6147 [V_MODEL_RADIO]: `vModelRadio`, 6148 [V_MODEL_CHECKBOX]: `vModelCheckbox`, 6149 [V_MODEL_TEXT]: `vModelText`, 6150 [V_MODEL_SELECT]: `vModelSelect`, 6151 [V_MODEL_DYNAMIC]: `vModelDynamic`, 6152 [V_ON_WITH_MODIFIERS]: `withModifiers`, 6153 [V_ON_WITH_KEYS]: `withKeys`, 6154 [V_SHOW]: `vShow`, 6155 [TRANSITION]: `Transition`, 6156 [TRANSITION_GROUP]: `TransitionGroup` 6157}); 6158 6159let decoder; 6160function decodeHtmlBrowser(raw, asAttr = false) { 6161 if (!decoder) { 6162 decoder = document.createElement("div"); 6163 } 6164 if (asAttr) { 6165 decoder.innerHTML = `<div foo="${raw.replace(/"/g, """)}">`; 6166 return decoder.children[0].getAttribute("foo"); 6167 } else { 6168 decoder.innerHTML = raw; 6169 return decoder.textContent; 6170 } 6171} 6172 6173const parserOptions = { 6174 parseMode: "html", 6175 isVoidTag: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.isVoidTag, 6176 isNativeTag: (tag) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isHTMLTag)(tag) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSVGTag)(tag) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isMathMLTag)(tag), 6177 isPreTag: (tag) => tag === "pre", 6178 isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea", 6179 decodeEntities: decodeHtmlBrowser , 6180 isBuiltInComponent: (tag) => { 6181 if (tag === "Transition" || tag === "transition") { 6182 return TRANSITION; 6183 } else if (tag === "TransitionGroup" || tag === "transition-group") { 6184 return TRANSITION_GROUP; 6185 } 6186 }, 6187 // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher 6188 getNamespace(tag, parent, rootNamespace) { 6189 let ns = parent ? parent.ns : rootNamespace; 6190 if (parent && ns === 2) { 6191 if (parent.tag === "annotation-xml") { 6192 if (tag === "svg") { 6193 return 1; 6194 } 6195 if (parent.props.some( 6196 (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml") 6197 )) { 6198 ns = 0; 6199 } 6200 } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") { 6201 ns = 0; 6202 } 6203 } else if (parent && ns === 1) { 6204 if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") { 6205 ns = 0; 6206 } 6207 } 6208 if (ns === 0) { 6209 if (tag === "svg") { 6210 return 1; 6211 } 6212 if (tag === "math") { 6213 return 2; 6214 } 6215 } 6216 return ns; 6217 } 6218}; 6219 6220const transformStyle = (node) => { 6221 if (node.type === 1) { 6222 node.props.forEach((p, i) => { 6223 if (p.type === 6 && p.name === "style" && p.value) { 6224 node.props[i] = { 6225 type: 7, 6226 name: `bind`, 6227 arg: (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`style`, true, p.loc), 6228 exp: parseInlineCSS(p.value.content, p.loc), 6229 modifiers: [], 6230 loc: p.loc 6231 }; 6232 } 6233 }); 6234 } 6235}; 6236const parseInlineCSS = (cssText, loc) => { 6237 const normalized = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.parseStringStyle)(cssText); 6238 return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)( 6239 JSON.stringify(normalized), 6240 false, 6241 loc, 6242 3 6243 ); 6244}; 6245 6246function createDOMCompilerError(code, loc) { 6247 return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompilerError)( 6248 code, 6249 loc, 6250 true ? DOMErrorMessages : 0 6251 ); 6252} 6253const DOMErrorCodes = { 6254 "X_V_HTML_NO_EXPRESSION": 53, 6255 "53": "X_V_HTML_NO_EXPRESSION", 6256 "X_V_HTML_WITH_CHILDREN": 54, 6257 "54": "X_V_HTML_WITH_CHILDREN", 6258 "X_V_TEXT_NO_EXPRESSION": 55, 6259 "55": "X_V_TEXT_NO_EXPRESSION", 6260 "X_V_TEXT_WITH_CHILDREN": 56, 6261 "56": "X_V_TEXT_WITH_CHILDREN", 6262 "X_V_MODEL_ON_INVALID_ELEMENT": 57, 6263 "57": "X_V_MODEL_ON_INVALID_ELEMENT", 6264 "X_V_MODEL_ARG_ON_ELEMENT": 58, 6265 "58": "X_V_MODEL_ARG_ON_ELEMENT", 6266 "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59, 6267 "59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT", 6268 "X_V_MODEL_UNNECESSARY_VALUE": 60, 6269 "60": "X_V_MODEL_UNNECESSARY_VALUE", 6270 "X_V_SHOW_NO_EXPRESSION": 61, 6271 "61": "X_V_SHOW_NO_EXPRESSION", 6272 "X_TRANSITION_INVALID_CHILDREN": 62, 6273 "62": "X_TRANSITION_INVALID_CHILDREN", 6274 "X_IGNORED_SIDE_EFFECT_TAG": 63, 6275 "63": "X_IGNORED_SIDE_EFFECT_TAG", 6276 "__EXTEND_POINT__": 64, 6277 "64": "__EXTEND_POINT__" 6278}; 6279const DOMErrorMessages = { 6280 [53]: `v-html is missing expression.`, 6281 [54]: `v-html will override element children.`, 6282 [55]: `v-text is missing expression.`, 6283 [56]: `v-text will override element children.`, 6284 [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`, 6285 [58]: `v-model argument is not supported on plain elements.`, 6286 [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`, 6287 [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`, 6288 [61]: `v-show is missing expression.`, 6289 [62]: `<Transition> expects exactly one child element or component.`, 6290 [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.` 6291}; 6292 6293const transformVHtml = (dir, node, context) => { 6294 const { exp, loc } = dir; 6295 if (!exp) { 6296 context.onError( 6297 createDOMCompilerError(53, loc) 6298 ); 6299 } 6300 if (node.children.length) { 6301 context.onError( 6302 createDOMCompilerError(54, loc) 6303 ); 6304 node.children.length = 0; 6305 } 6306 return { 6307 props: [ 6308 (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty)( 6309 (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`innerHTML`, true, loc), 6310 exp || (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)("", true) 6311 ) 6312 ] 6313 }; 6314}; 6315 6316const transformVText = (dir, node, context) => { 6317 const { exp, loc } = dir; 6318 if (!exp) { 6319 context.onError( 6320 createDOMCompilerError(55, loc) 6321 ); 6322 } 6323 if (node.children.length) { 6324 context.onError( 6325 createDOMCompilerError(56, loc) 6326 ); 6327 node.children.length = 0; 6328 } 6329 return { 6330 props: [ 6331 (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty)( 6332 (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`textContent`, true), 6333 exp ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getConstantType)(exp, context) > 0 ? exp : (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression)( 6334 context.helperString(_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_DISPLAY_STRING), 6335 [exp], 6336 loc 6337 ) : (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)("", true) 6338 ) 6339 ] 6340 }; 6341}; 6342 6343const transformModel = (dir, node, context) => { 6344 const baseResult = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformModel)(dir, node, context); 6345 if (!baseResult.props.length || node.tagType === 1) { 6346 return baseResult; 6347 } 6348 if (dir.arg) { 6349 context.onError( 6350 createDOMCompilerError( 6351 58, 6352 dir.arg.loc 6353 ) 6354 ); 6355 } 6356 function checkDuplicatedValue() { 6357 const value = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findDir)(node, "bind"); 6358 if (value && (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticArgOf)(value.arg, "value")) { 6359 context.onError( 6360 createDOMCompilerError( 6361 60, 6362 value.loc 6363 ) 6364 ); 6365 } 6366 } 6367 const { tag } = node; 6368 const isCustomElement = context.isCustomElement(tag); 6369 if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) { 6370 let directiveToUse = V_MODEL_TEXT; 6371 let isInvalidType = false; 6372 if (tag === "input" || isCustomElement) { 6373 const type = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findProp)(node, `type`); 6374 if (type) { 6375 if (type.type === 7) { 6376 directiveToUse = V_MODEL_DYNAMIC; 6377 } else if (type.value) { 6378 switch (type.value.content) { 6379 case "radio": 6380 directiveToUse = V_MODEL_RADIO; 6381 break; 6382 case "checkbox": 6383 directiveToUse = V_MODEL_CHECKBOX; 6384 break; 6385 case "file": 6386 isInvalidType = true; 6387 context.onError( 6388 createDOMCompilerError( 6389 59, 6390 dir.loc 6391 ) 6392 ); 6393 break; 6394 default: 6395 true && checkDuplicatedValue(); 6396 break; 6397 } 6398 } 6399 } else if ((0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.hasDynamicKeyVBind)(node)) { 6400 directiveToUse = V_MODEL_DYNAMIC; 6401 } else { 6402 true && checkDuplicatedValue(); 6403 } 6404 } else if (tag === "select") { 6405 directiveToUse = V_MODEL_SELECT; 6406 } else { 6407 true && checkDuplicatedValue(); 6408 } 6409 if (!isInvalidType) { 6410 baseResult.needRuntime = context.helper(directiveToUse); 6411 } 6412 } else { 6413 context.onError( 6414 createDOMCompilerError( 6415 57, 6416 dir.loc 6417 ) 6418 ); 6419 } 6420 baseResult.props = baseResult.props.filter( 6421 (p) => !(p.key.type === 4 && p.key.content === "modelValue") 6422 ); 6423 return baseResult; 6424}; 6425 6426const isEventOptionModifier = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)(`passive,once,capture`); 6427const isNonKeyModifier = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)( 6428 // event propagation management 6429 `stop,prevent,self,ctrl,shift,alt,meta,exact,middle` 6430); 6431const maybeKeyModifier = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)("left,right"); 6432const isKeyboardEvent = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)(`onkeyup,onkeydown,onkeypress`); 6433const resolveModifiers = (key, modifiers, context, loc) => { 6434 const keyModifiers = []; 6435 const nonKeyModifiers = []; 6436 const eventOptionModifiers = []; 6437 for (let i = 0; i < modifiers.length; i++) { 6438 const modifier = modifiers[i].content; 6439 if (modifier === "native" && (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.checkCompatEnabled)( 6440 "COMPILER_V_ON_NATIVE", 6441 context, 6442 loc 6443 )) { 6444 eventOptionModifiers.push(modifier); 6445 } else if (isEventOptionModifier(modifier)) { 6446 eventOptionModifiers.push(modifier); 6447 } else { 6448 if (maybeKeyModifier(modifier)) { 6449 if ((0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key)) { 6450 if (isKeyboardEvent(key.content.toLowerCase())) { 6451 keyModifiers.push(modifier); 6452 } else { 6453 nonKeyModifiers.push(modifier); 6454 } 6455 } else { 6456 keyModifiers.push(modifier); 6457 nonKeyModifiers.push(modifier); 6458 } 6459 } else { 6460 if (isNonKeyModifier(modifier)) { 6461 nonKeyModifiers.push(modifier); 6462 } else { 6463 keyModifiers.push(modifier); 6464 } 6465 } 6466 } 6467 } 6468 return { 6469 keyModifiers, 6470 nonKeyModifiers, 6471 eventOptionModifiers 6472 }; 6473}; 6474const transformClick = (key, event) => { 6475 const isStaticClick = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key) && key.content.toLowerCase() === "onclick"; 6476 return isStaticClick ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(event, true) : key.type !== 4 ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompoundExpression)([ 6477 `(`, 6478 key, 6479 `) === "onClick" ? "${event}" : (`, 6480 key, 6481 `)` 6482 ]) : key; 6483}; 6484const transformOn = (dir, node, context) => { 6485 return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformOn)(dir, node, context, (baseResult) => { 6486 const { modifiers } = dir; 6487 if (!modifiers.length) return baseResult; 6488 let { key, value: handlerExp } = baseResult.props[0]; 6489 const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc); 6490 if (nonKeyModifiers.includes("right")) { 6491 key = transformClick(key, `onContextmenu`); 6492 } 6493 if (nonKeyModifiers.includes("middle")) { 6494 key = transformClick(key, `onMouseup`); 6495 } 6496 if (nonKeyModifiers.length) { 6497 handlerExp = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression)(context.helper(V_ON_WITH_MODIFIERS), [ 6498 handlerExp, 6499 JSON.stringify(nonKeyModifiers) 6500 ]); 6501 } 6502 if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard 6503 (!(0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key) || isKeyboardEvent(key.content.toLowerCase()))) { 6504 handlerExp = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression)(context.helper(V_ON_WITH_KEYS), [ 6505 handlerExp, 6506 JSON.stringify(keyModifiers) 6507 ]); 6508 } 6509 if (eventOptionModifiers.length) { 6510 const modifierPostfix = eventOptionModifiers.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize).join(""); 6511 key = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key) ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`${key.content}${modifierPostfix}`, true) : (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompoundExpression)([`(`, key, `) + "${modifierPostfix}"`]); 6512 } 6513 return { 6514 props: [(0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty)(key, handlerExp)] 6515 }; 6516 }); 6517}; 6518 6519const transformShow = (dir, node, context) => { 6520 const { exp, loc } = dir; 6521 if (!exp) { 6522 context.onError( 6523 createDOMCompilerError(61, loc) 6524 ); 6525 } 6526 return { 6527 props: [], 6528 needRuntime: context.helper(V_SHOW) 6529 }; 6530}; 6531 6532const transformTransition = (node, context) => { 6533 if (node.type === 1 && node.tagType === 1) { 6534 const component = context.isBuiltInComponent(node.tag); 6535 if (component === TRANSITION) { 6536 return () => { 6537 if (!node.children.length) { 6538 return; 6539 } 6540 if (hasMultipleChildren(node)) { 6541 context.onError( 6542 createDOMCompilerError( 6543 62, 6544 { 6545 start: node.children[0].loc.start, 6546 end: node.children[node.children.length - 1].loc.end, 6547 source: "" 6548 } 6549 ) 6550 ); 6551 } 6552 const child = node.children[0]; 6553 if (child.type === 1) { 6554 for (const p of child.props) { 6555 if (p.type === 7 && p.name === "show") { 6556 node.props.push({ 6557 type: 6, 6558 name: "persisted", 6559 nameLoc: node.loc, 6560 value: void 0, 6561 loc: node.loc 6562 }); 6563 } 6564 } 6565 } 6566 }; 6567 } 6568 } 6569}; 6570function hasMultipleChildren(node) { 6571 const children = node.children = node.children.filter( 6572 (c) => c.type !== 3 && !(c.type === 2 && !c.content.trim()) 6573 ); 6574 const child = children[0]; 6575 return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren); 6576} 6577 6578const ignoreSideEffectTags = (node, context) => { 6579 if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) { 6580 true && context.onError( 6581 createDOMCompilerError( 6582 63, 6583 node.loc 6584 ) 6585 ); 6586 context.removeNode(); 6587 } 6588}; 6589 6590function isValidHTMLNesting(parent, child) { 6591 if (parent in onlyValidChildren) { 6592 return onlyValidChildren[parent].has(child); 6593 } 6594 if (child in onlyValidParents) { 6595 return onlyValidParents[child].has(parent); 6596 } 6597 if (parent in knownInvalidChildren) { 6598 if (knownInvalidChildren[parent].has(child)) return false; 6599 } 6600 if (child in knownInvalidParents) { 6601 if (knownInvalidParents[child].has(parent)) return false; 6602 } 6603 return true; 6604} 6605const headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]); 6606const emptySet = /* @__PURE__ */ new Set([]); 6607const onlyValidChildren = { 6608 head: /* @__PURE__ */ new Set([ 6609 "base", 6610 "basefront", 6611 "bgsound", 6612 "link", 6613 "meta", 6614 "title", 6615 "noscript", 6616 "noframes", 6617 "style", 6618 "script", 6619 "template" 6620 ]), 6621 optgroup: /* @__PURE__ */ new Set(["option"]), 6622 select: /* @__PURE__ */ new Set(["optgroup", "option", "hr"]), 6623 // table 6624 table: /* @__PURE__ */ new Set(["caption", "colgroup", "tbody", "tfoot", "thead"]), 6625 tr: /* @__PURE__ */ new Set(["td", "th"]), 6626 colgroup: /* @__PURE__ */ new Set(["col"]), 6627 tbody: /* @__PURE__ */ new Set(["tr"]), 6628 thead: /* @__PURE__ */ new Set(["tr"]), 6629 tfoot: /* @__PURE__ */ new Set(["tr"]), 6630 // these elements can not have any children elements 6631 script: emptySet, 6632 iframe: emptySet, 6633 option: emptySet, 6634 textarea: emptySet, 6635 style: emptySet, 6636 title: emptySet 6637}; 6638const onlyValidParents = { 6639 // sections 6640 html: emptySet, 6641 body: /* @__PURE__ */ new Set(["html"]), 6642 head: /* @__PURE__ */ new Set(["html"]), 6643 // table 6644 td: /* @__PURE__ */ new Set(["tr"]), 6645 colgroup: /* @__PURE__ */ new Set(["table"]), 6646 caption: /* @__PURE__ */ new Set(["table"]), 6647 tbody: /* @__PURE__ */ new Set(["table"]), 6648 tfoot: /* @__PURE__ */ new Set(["table"]), 6649 col: /* @__PURE__ */ new Set(["colgroup"]), 6650 th: /* @__PURE__ */ new Set(["tr"]), 6651 thead: /* @__PURE__ */ new Set(["table"]), 6652 tr: /* @__PURE__ */ new Set(["tbody", "thead", "tfoot"]), 6653 // data list 6654 dd: /* @__PURE__ */ new Set(["dl", "div"]), 6655 dt: /* @__PURE__ */ new Set(["dl", "div"]), 6656 // other 6657 figcaption: /* @__PURE__ */ new Set(["figure"]), 6658 // li: new Set(["ul", "ol"]), 6659 summary: /* @__PURE__ */ new Set(["details"]), 6660 area: /* @__PURE__ */ new Set(["map"]) 6661}; 6662const knownInvalidChildren = { 6663 p: /* @__PURE__ */ new Set([ 6664 "address", 6665 "article", 6666 "aside", 6667 "blockquote", 6668 "center", 6669 "details", 6670 "dialog", 6671 "dir", 6672 "div", 6673 "dl", 6674 "fieldset", 6675 "figure", 6676 "footer", 6677 "form", 6678 "h1", 6679 "h2", 6680 "h3", 6681 "h4", 6682 "h5", 6683 "h6", 6684 "header", 6685 "hgroup", 6686 "hr", 6687 "li", 6688 "main", 6689 "nav", 6690 "menu", 6691 "ol", 6692 "p", 6693 "pre", 6694 "section", 6695 "table", 6696 "ul" 6697 ]), 6698 svg: /* @__PURE__ */ new Set([ 6699 "b", 6700 "blockquote", 6701 "br", 6702 "code", 6703 "dd", 6704 "div", 6705 "dl", 6706 "dt", 6707 "em", 6708 "embed", 6709 "h1", 6710 "h2", 6711 "h3", 6712 "h4", 6713 "h5", 6714 "h6", 6715 "hr", 6716 "i", 6717 "img", 6718 "li", 6719 "menu", 6720 "meta", 6721 "ol", 6722 "p", 6723 "pre", 6724 "ruby", 6725 "s", 6726 "small", 6727 "span", 6728 "strong", 6729 "sub", 6730 "sup", 6731 "table", 6732 "u", 6733 "ul", 6734 "var" 6735 ]) 6736}; 6737const knownInvalidParents = { 6738 a: /* @__PURE__ */ new Set(["a"]), 6739 button: /* @__PURE__ */ new Set(["button"]), 6740 dd: /* @__PURE__ */ new Set(["dd", "dt"]), 6741 dt: /* @__PURE__ */ new Set(["dd", "dt"]), 6742 form: /* @__PURE__ */ new Set(["form"]), 6743 li: /* @__PURE__ */ new Set(["li"]), 6744 h1: headings, 6745 h2: headings, 6746 h3: headings, 6747 h4: headings, 6748 h5: headings, 6749 h6: headings 6750}; 6751 6752const validateHtmlNesting = (node, context) => { 6753 if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) { 6754 const error = new SyntaxError( 6755 `<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.` 6756 ); 6757 error.loc = node.loc; 6758 context.onWarn(error); 6759 } 6760}; 6761 6762const DOMNodeTransforms = [ 6763 transformStyle, 6764 ... true ? [transformTransition, validateHtmlNesting] : 0 6765]; 6766const DOMDirectiveTransforms = { 6767 cloak: _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.noopDirectiveTransform, 6768 html: transformVHtml, 6769 text: transformVText, 6770 model: transformModel, 6771 // override compiler-core 6772 on: transformOn, 6773 // override compiler-core 6774 show: transformShow 6775}; 6776function compile(src, options = {}) { 6777 return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseCompile)( 6778 src, 6779 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, parserOptions, options, { 6780 nodeTransforms: [ 6781 // ignore <script> and <tag> 6782 // this is not put inside DOMNodeTransforms because that list is used 6783 // by compiler-ssr to generate vnode fallback branches 6784 ignoreSideEffectTags, 6785 ...DOMNodeTransforms, 6786 ...options.nodeTransforms || [] 6787 ], 6788 directiveTransforms: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)( 6789 {}, 6790 DOMDirectiveTransforms, 6791 options.directiveTransforms || {} 6792 ), 6793 transformHoist: null 6794 }) 6795 ); 6796} 6797function parse(template, options = {}) { 6798 return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseParse)(template, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, parserOptions, options)); 6799} 6800 6801 6802 6803 6804/***/ }), 6805
vendor: 755 bytes, lines 6806-6823
6806/***/ "./node_modules/@vue/devtools-api/lib/esm/const.js": 6807/*!*********************************************************!*\ 6808 !*** ./node_modules/@vue/devtools-api/lib/esm/const.js ***! 6809 \*********************************************************/ 6810/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 6811 6812"use strict"; 6813__webpack_require__.r(__webpack_exports__); 6814/* harmony export */ __webpack_require__.d(__webpack_exports__, { 6815/* harmony export */ HOOK_PLUGIN_SETTINGS_SET: () => (/* binding */ HOOK_PLUGIN_SETTINGS_SET), 6816/* harmony export */ HOOK_SETUP: () => (/* binding */ HOOK_SETUP) 6817/* harmony export */ }); 6818const HOOK_SETUP = 'devtools-plugin:setup'; 6819const HOOK_PLUGIN_SETTINGS_SET = 'plugin:settings:set'; 6820 6821 6822/***/ }), 6823
vendor: 1,156 bytes, lines 6824-6852
6824/***/ "./node_modules/@vue/devtools-api/lib/esm/env.js": 6825/*!*******************************************************!*\ 6826 !*** ./node_modules/@vue/devtools-api/lib/esm/env.js ***! 6827 \*******************************************************/ 6828/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 6829 6830"use strict"; 6831__webpack_require__.r(__webpack_exports__); 6832/* harmony export */ __webpack_require__.d(__webpack_exports__, { 6833/* harmony export */ getDevtoolsGlobalHook: () => (/* binding */ getDevtoolsGlobalHook), 6834/* harmony export */ getTarget: () => (/* binding */ getTarget), 6835/* harmony export */ isProxyAvailable: () => (/* binding */ isProxyAvailable) 6836/* harmony export */ }); 6837function getDevtoolsGlobalHook() { 6838 return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__; 6839} 6840function getTarget() { 6841 // @ts-expect-error navigator and windows are not available in all environments 6842 return (typeof navigator !== 'undefined' && typeof window !== 'undefined') 6843 ? window 6844 : typeof globalThis !== 'undefined' 6845 ? globalThis 6846 : {}; 6847} 6848const isProxyAvailable = typeof Proxy === 'function'; 6849 6850 6851/***/ }), 6852
vendor: 2,405 bytes, lines 6853-6900
6853/***/ "./node_modules/@vue/devtools-api/lib/esm/index.js": 6854/*!*********************************************************!*\ 6855 !*** ./node_modules/@vue/devtools-api/lib/esm/index.js ***! 6856 \*********************************************************/ 6857/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 6858 6859"use strict"; 6860__webpack_require__.r(__webpack_exports__); 6861/* harmony export */ __webpack_require__.d(__webpack_exports__, { 6862/* harmony export */ isPerformanceSupported: () => (/* reexport safe */ _time_js__WEBPACK_IMPORTED_MODULE_0__.isPerformanceSupported), 6863/* harmony export */ now: () => (/* reexport safe */ _time_js__WEBPACK_IMPORTED_MODULE_0__.now), 6864/* harmony export */ setupDevtoolsPlugin: () => (/* binding */ setupDevtoolsPlugin) 6865/* harmony export */ }); 6866/* harmony import */ var _env_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./env.js */ "./node_modules/@vue/devtools-api/lib/esm/env.js"); 6867/* harmony import */ var _const_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./const.js */ "./node_modules/@vue/devtools-api/lib/esm/const.js"); 6868/* harmony import */ var _proxy_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./proxy.js */ "./node_modules/@vue/devtools-api/lib/esm/proxy.js"); 6869/* harmony import */ var _time_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./time.js */ "./node_modules/@vue/devtools-api/lib/esm/time.js"); 6870 6871 6872 6873 6874 6875 6876function setupDevtoolsPlugin(pluginDescriptor, setupFn) { 6877 const descriptor = pluginDescriptor; 6878 const target = (0,_env_js__WEBPACK_IMPORTED_MODULE_1__.getTarget)(); 6879 const hook = (0,_env_js__WEBPACK_IMPORTED_MODULE_1__.getDevtoolsGlobalHook)(); 6880 const enableProxy = _env_js__WEBPACK_IMPORTED_MODULE_1__.isProxyAvailable && descriptor.enableEarlyProxy; 6881 if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) { 6882 hook.emit(_const_js__WEBPACK_IMPORTED_MODULE_2__.HOOK_SETUP, pluginDescriptor, setupFn); 6883 } 6884 else { 6885 const proxy = enableProxy ? new _proxy_js__WEBPACK_IMPORTED_MODULE_3__.ApiProxy(descriptor, hook) : null; 6886 const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || []; 6887 list.push({ 6888 pluginDescriptor: descriptor, 6889 setupFn, 6890 proxy, 6891 }); 6892 if (proxy) { 6893 setupFn(proxy.proxiedTarget); 6894 } 6895 } 6896} 6897 6898 6899/***/ }), 6900
vendor: 4,390 bytes, lines 6901-7024
6901/***/ "./node_modules/@vue/devtools-api/lib/esm/proxy.js": 6902/*!*********************************************************!*\ 6903 !*** ./node_modules/@vue/devtools-api/lib/esm/proxy.js ***! 6904 \*********************************************************/ 6905/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 6906 6907"use strict"; 6908__webpack_require__.r(__webpack_exports__); 6909/* harmony export */ __webpack_require__.d(__webpack_exports__, { 6910/* harmony export */ ApiProxy: () => (/* binding */ ApiProxy) 6911/* harmony export */ }); 6912/* harmony import */ var _const_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./const.js */ "./node_modules/@vue/devtools-api/lib/esm/const.js"); 6913/* harmony import */ var _time_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./time.js */ "./node_modules/@vue/devtools-api/lib/esm/time.js"); 6914 6915 6916class ApiProxy { 6917 constructor(plugin, hook) { 6918 this.target = null; 6919 this.targetQueue = []; 6920 this.onQueue = []; 6921 this.plugin = plugin; 6922 this.hook = hook; 6923 const defaultSettings = {}; 6924 if (plugin.settings) { 6925 for (const id in plugin.settings) { 6926 const item = plugin.settings[id]; 6927 defaultSettings[id] = item.defaultValue; 6928 } 6929 } 6930 const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`; 6931 let currentSettings = Object.assign({}, defaultSettings); 6932 try { 6933 const raw = localStorage.getItem(localSettingsSaveId); 6934 const data = JSON.parse(raw); 6935 Object.assign(currentSettings, data); 6936 } 6937 catch (e) { 6938 // noop 6939 } 6940 this.fallbacks = { 6941 getSettings() { 6942 return currentSettings; 6943 }, 6944 setSettings(value) { 6945 try { 6946 localStorage.setItem(localSettingsSaveId, JSON.stringify(value)); 6947 } 6948 catch (e) { 6949 // noop 6950 } 6951 currentSettings = value; 6952 }, 6953 now() { 6954 return (0,_time_js__WEBPACK_IMPORTED_MODULE_0__.now)(); 6955 }, 6956 }; 6957 if (hook) { 6958 hook.on(_const_js__WEBPACK_IMPORTED_MODULE_1__.HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => { 6959 if (pluginId === this.plugin.id) { 6960 this.fallbacks.setSettings(value); 6961 } 6962 }); 6963 } 6964 this.proxiedOn = new Proxy({}, { 6965 get: (_target, prop) => { 6966 if (this.target) { 6967 return this.target.on[prop]; 6968 } 6969 else { 6970 return (...args) => { 6971 this.onQueue.push({ 6972 method: prop, 6973 args, 6974 }); 6975 }; 6976 } 6977 }, 6978 }); 6979 this.proxiedTarget = new Proxy({}, { 6980 get: (_target, prop) => { 6981 if (this.target) { 6982 return this.target[prop]; 6983 } 6984 else if (prop === 'on') { 6985 return this.proxiedOn; 6986 } 6987 else if (Object.keys(this.fallbacks).includes(prop)) { 6988 return (...args) => { 6989 this.targetQueue.push({ 6990 method: prop, 6991 args, 6992 resolve: () => { }, 6993 }); 6994 return this.fallbacks[prop](...args); 6995 }; 6996 } 6997 else { 6998 return (...args) => { 6999 return new Promise((resolve) => { 7000 this.targetQueue.push({ 7001 method: prop, 7002 args, 7003 resolve, 7004 }); 7005 }); 7006 }; 7007 } 7008 }, 7009 }); 7010 } 7011 async setRealTarget(target) { 7012 this.target = target; 7013 for (const item of this.onQueue) { 7014 this.target.on[item.method](...item.args); 7015 } 7016 for (const item of this.targetQueue) { 7017 item.resolve(await this.target[item.method](...item.args)); 7018 } 7019 } 7020} 7021 7022 7023/***/ }), 7024
vendor: 1,271 bytes, lines 7025-7063
7025/***/ "./node_modules/@vue/devtools-api/lib/esm/time.js": 7026/*!********************************************************!*\ 7027 !*** ./node_modules/@vue/devtools-api/lib/esm/time.js ***! 7028 \********************************************************/ 7029/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 7030 7031"use strict"; 7032__webpack_require__.r(__webpack_exports__); 7033/* harmony export */ __webpack_require__.d(__webpack_exports__, { 7034/* harmony export */ isPerformanceSupported: () => (/* binding */ isPerformanceSupported), 7035/* harmony export */ now: () => (/* binding */ now) 7036/* harmony export */ }); 7037let supported; 7038let perf; 7039function isPerformanceSupported() { 7040 var _a; 7041 if (supported !== undefined) { 7042 return supported; 7043 } 7044 if (typeof window !== 'undefined' && window.performance) { 7045 supported = true; 7046 perf = window.performance; 7047 } 7048 else if (typeof globalThis !== 'undefined' && ((_a = globalThis.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) { 7049 supported = true; 7050 perf = globalThis.perf_hooks.performance; 7051 } 7052 else { 7053 supported = false; 7054 } 7055 return supported; 7056} 7057function now() { 7058 return isPerformanceSupported() ? perf.now() : Date.now(); 7059} 7060 7061 7062/***/ }), 7063
vendor: 55,703 bytes, lines 7064-9014
7064/***/ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js": 7065/*!*********************************************************************!*\ 7066 !*** ./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js ***! 7067 \*********************************************************************/ 7068/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 7069 7070"use strict"; 7071__webpack_require__.r(__webpack_exports__); 7072/* harmony export */ __webpack_require__.d(__webpack_exports__, { 7073/* harmony export */ ARRAY_ITERATE_KEY: () => (/* binding */ ARRAY_ITERATE_KEY), 7074/* harmony export */ EffectFlags: () => (/* binding */ EffectFlags), 7075/* harmony export */ EffectScope: () => (/* binding */ EffectScope), 7076/* harmony export */ ITERATE_KEY: () => (/* binding */ ITERATE_KEY), 7077/* harmony export */ MAP_KEY_ITERATE_KEY: () => (/* binding */ MAP_KEY_ITERATE_KEY), 7078/* harmony export */ ReactiveEffect: () => (/* binding */ ReactiveEffect), 7079/* harmony export */ ReactiveFlags: () => (/* binding */ ReactiveFlags), 7080/* harmony export */ TrackOpTypes: () => (/* binding */ TrackOpTypes), 7081/* harmony export */ TriggerOpTypes: () => (/* binding */ TriggerOpTypes), 7082/* harmony export */ WatchErrorCodes: () => (/* binding */ WatchErrorCodes), 7083/* harmony export */ computed: () => (/* binding */ computed), 7084/* harmony export */ customRef: () => (/* binding */ customRef), 7085/* harmony export */ effect: () => (/* binding */ effect), 7086/* harmony export */ effectScope: () => (/* binding */ effectScope), 7087/* harmony export */ enableTracking: () => (/* binding */ enableTracking), 7088/* harmony export */ getCurrentScope: () => (/* binding */ getCurrentScope), 7089/* harmony export */ getCurrentWatcher: () => (/* binding */ getCurrentWatcher), 7090/* harmony export */ isProxy: () => (/* binding */ isProxy), 7091/* harmony export */ isReactive: () => (/* binding */ isReactive), 7092/* harmony export */ isReadonly: () => (/* binding */ isReadonly), 7093/* harmony export */ isRef: () => (/* binding */ isRef), 7094/* harmony export */ isShallow: () => (/* binding */ isShallow), 7095/* harmony export */ markRaw: () => (/* binding */ markRaw), 7096/* harmony export */ onEffectCleanup: () => (/* binding */ onEffectCleanup), 7097/* harmony export */ onScopeDispose: () => (/* binding */ onScopeDispose), 7098/* harmony export */ onWatcherCleanup: () => (/* binding */ onWatcherCleanup), 7099/* harmony export */ pauseTracking: () => (/* binding */ pauseTracking), 7100/* harmony export */ proxyRefs: () => (/* binding */ proxyRefs), 7101/* harmony export */ reactive: () => (/* binding */ reactive), 7102/* harmony export */ reactiveReadArray: () => (/* binding */ reactiveReadArray), 7103/* harmony export */ readonly: () => (/* binding */ readonly), 7104/* harmony export */ ref: () => (/* binding */ ref), 7105/* harmony export */ resetTracking: () => (/* binding */ resetTracking), 7106/* harmony export */ shallowReactive: () => (/* binding */ shallowReactive), 7107/* harmony export */ shallowReadArray: () => (/* binding */ shallowReadArray), 7108/* harmony export */ shallowReadonly: () => (/* binding */ shallowReadonly), 7109/* harmony export */ shallowRef: () => (/* binding */ shallowRef), 7110/* harmony export */ stop: () => (/* binding */ stop), 7111/* harmony export */ toRaw: () => (/* binding */ toRaw), 7112/* harmony export */ toReactive: () => (/* binding */ toReactive), 7113/* harmony export */ toReadonly: () => (/* binding */ toReadonly), 7114/* harmony export */ toRef: () => (/* binding */ toRef), 7115/* harmony export */ toRefs: () => (/* binding */ toRefs), 7116/* harmony export */ toValue: () => (/* binding */ toValue), 7117/* harmony export */ track: () => (/* binding */ track), 7118/* harmony export */ traverse: () => (/* binding */ traverse), 7119/* harmony export */ trigger: () => (/* binding */ trigger), 7120/* harmony export */ triggerRef: () => (/* binding */ triggerRef), 7121/* harmony export */ unref: () => (/* binding */ unref), 7122/* harmony export */ watch: () => (/* binding */ watch) 7123/* harmony export */ }); 7124/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 7125/** 7126* @vue/reactivity v3.5.13 7127* (c) 2018-present Yuxi (Evan) You and Vue contributors 7128* @license MIT 7129**/ 7130 7131 7132function warn(msg, ...args) { 7133 console.warn(`[Vue warn] ${msg}`, ...args); 7134} 7135 7136let activeEffectScope; 7137class EffectScope { 7138 constructor(detached = false) { 7139 this.detached = detached; 7140 /** 7141 * @internal 7142 */ 7143 this._active = true; 7144 /** 7145 * @internal 7146 */ 7147 this.effects = []; 7148 /** 7149 * @internal 7150 */ 7151 this.cleanups = []; 7152 this._isPaused = false; 7153 this.parent = activeEffectScope; 7154 if (!detached && activeEffectScope) { 7155 this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push( 7156 this 7157 ) - 1; 7158 } 7159 } 7160 get active() { 7161 return this._active; 7162 } 7163 pause() { 7164 if (this._active) { 7165 this._isPaused = true; 7166 let i, l; 7167 if (this.scopes) { 7168 for (i = 0, l = this.scopes.length; i < l; i++) { 7169 this.scopes[i].pause(); 7170 } 7171 } 7172 for (i = 0, l = this.effects.length; i < l; i++) { 7173 this.effects[i].pause(); 7174 } 7175 } 7176 } 7177 /** 7178 * Resumes the effect scope, including all child scopes and effects. 7179 */ 7180 resume() { 7181 if (this._active) { 7182 if (this._isPaused) { 7183 this._isPaused = false; 7184 let i, l; 7185 if (this.scopes) { 7186 for (i = 0, l = this.scopes.length; i < l; i++) { 7187 this.scopes[i].resume(); 7188 } 7189 } 7190 for (i = 0, l = this.effects.length; i < l; i++) { 7191 this.effects[i].resume(); 7192 } 7193 } 7194 } 7195 } 7196 run(fn) { 7197 if (this._active) { 7198 const currentEffectScope = activeEffectScope; 7199 try { 7200 activeEffectScope = this; 7201 return fn(); 7202 } finally { 7203 activeEffectScope = currentEffectScope; 7204 } 7205 } else if (true) { 7206 warn(`cannot run an inactive effect scope.`); 7207 } 7208 } 7209 /** 7210 * This should only be called on non-detached scopes 7211 * @internal 7212 */ 7213 on() { 7214 activeEffectScope = this; 7215 } 7216 /** 7217 * This should only be called on non-detached scopes 7218 * @internal 7219 */ 7220 off() { 7221 activeEffectScope = this.parent; 7222 } 7223 stop(fromParent) { 7224 if (this._active) { 7225 this._active = false; 7226 let i, l; 7227 for (i = 0, l = this.effects.length; i < l; i++) { 7228 this.effects[i].stop(); 7229 } 7230 this.effects.length = 0; 7231 for (i = 0, l = this.cleanups.length; i < l; i++) { 7232 this.cleanups[i](); 7233 } 7234 this.cleanups.length = 0; 7235 if (this.scopes) { 7236 for (i = 0, l = this.scopes.length; i < l; i++) { 7237 this.scopes[i].stop(true); 7238 } 7239 this.scopes.length = 0; 7240 } 7241 if (!this.detached && this.parent && !fromParent) { 7242 const last = this.parent.scopes.pop(); 7243 if (last && last !== this) { 7244 this.parent.scopes[this.index] = last; 7245 last.index = this.index; 7246 } 7247 } 7248 this.parent = void 0; 7249 } 7250 } 7251} 7252function effectScope(detached) { 7253 return new EffectScope(detached); 7254} 7255function getCurrentScope() { 7256 return activeEffectScope; 7257} 7258function onScopeDispose(fn, failSilently = false) { 7259 if (activeEffectScope) { 7260 activeEffectScope.cleanups.push(fn); 7261 } else if ( true && !failSilently) { 7262 warn( 7263 `onScopeDispose() is called when there is no active effect scope to be associated with.` 7264 ); 7265 } 7266} 7267 7268let activeSub; 7269const EffectFlags = { 7270 "ACTIVE": 1, 7271 "1": "ACTIVE", 7272 "RUNNING": 2, 7273 "2": "RUNNING", 7274 "TRACKING": 4, 7275 "4": "TRACKING", 7276 "NOTIFIED": 8, 7277 "8": "NOTIFIED", 7278 "DIRTY": 16, 7279 "16": "DIRTY", 7280 "ALLOW_RECURSE": 32, 7281 "32": "ALLOW_RECURSE", 7282 "PAUSED": 64, 7283 "64": "PAUSED" 7284}; 7285const pausedQueueEffects = /* @__PURE__ */ new WeakSet(); 7286class ReactiveEffect { 7287 constructor(fn) { 7288 this.fn = fn; 7289 /** 7290 * @internal 7291 */ 7292 this.deps = void 0; 7293 /** 7294 * @internal 7295 */ 7296 this.depsTail = void 0; 7297 /** 7298 * @internal 7299 */ 7300 this.flags = 1 | 4; 7301 /** 7302 * @internal 7303 */ 7304 this.next = void 0; 7305 /** 7306 * @internal 7307 */ 7308 this.cleanup = void 0; 7309 this.scheduler = void 0; 7310 if (activeEffectScope && activeEffectScope.active) { 7311 activeEffectScope.effects.push(this); 7312 } 7313 } 7314 pause() { 7315 this.flags |= 64; 7316 } 7317 resume() { 7318 if (this.flags & 64) { 7319 this.flags &= ~64; 7320 if (pausedQueueEffects.has(this)) { 7321 pausedQueueEffects.delete(this); 7322 this.trigger(); 7323 } 7324 } 7325 } 7326 /** 7327 * @internal 7328 */ 7329 notify() { 7330 if (this.flags & 2 && !(this.flags & 32)) { 7331 return; 7332 } 7333 if (!(this.flags & 8)) { 7334 batch(this); 7335 } 7336 } 7337 run() { 7338 if (!(this.flags & 1)) { 7339 return this.fn(); 7340 } 7341 this.flags |= 2; 7342 cleanupEffect(this); 7343 prepareDeps(this); 7344 const prevEffect = activeSub; 7345 const prevShouldTrack = shouldTrack; 7346 activeSub = this; 7347 shouldTrack = true; 7348 try { 7349 return this.fn(); 7350 } finally { 7351 if ( true && activeSub !== this) { 7352 warn( 7353 "Active effect was not restored correctly - this is likely a Vue internal bug." 7354 ); 7355 } 7356 cleanupDeps(this); 7357 activeSub = prevEffect; 7358 shouldTrack = prevShouldTrack; 7359 this.flags &= ~2; 7360 } 7361 } 7362 stop() { 7363 if (this.flags & 1) { 7364 for (let link = this.deps; link; link = link.nextDep) { 7365 removeSub(link); 7366 } 7367 this.deps = this.depsTail = void 0; 7368 cleanupEffect(this); 7369 this.onStop && this.onStop(); 7370 this.flags &= ~1; 7371 } 7372 } 7373 trigger() { 7374 if (this.flags & 64) { 7375 pausedQueueEffects.add(this); 7376 } else if (this.scheduler) { 7377 this.scheduler(); 7378 } else { 7379 this.runIfDirty(); 7380 } 7381 } 7382 /** 7383 * @internal 7384 */ 7385 runIfDirty() { 7386 if (isDirty(this)) { 7387 this.run(); 7388 } 7389 } 7390 get dirty() { 7391 return isDirty(this); 7392 } 7393} 7394let batchDepth = 0; 7395let batchedSub; 7396let batchedComputed; 7397function batch(sub, isComputed = false) { 7398 sub.flags |= 8; 7399 if (isComputed) { 7400 sub.next = batchedComputed; 7401 batchedComputed = sub; 7402 return; 7403 } 7404 sub.next = batchedSub; 7405 batchedSub = sub; 7406} 7407function startBatch() { 7408 batchDepth++; 7409} 7410function endBatch() { 7411 if (--batchDepth > 0) { 7412 return; 7413 } 7414 if (batchedComputed) { 7415 let e = batchedComputed; 7416 batchedComputed = void 0; 7417 while (e) { 7418 const next = e.next; 7419 e.next = void 0; 7420 e.flags &= ~8; 7421 e = next; 7422 } 7423 } 7424 let error; 7425 while (batchedSub) { 7426 let e = batchedSub; 7427 batchedSub = void 0; 7428 while (e) { 7429 const next = e.next; 7430 e.next = void 0; 7431 e.flags &= ~8; 7432 if (e.flags & 1) { 7433 try { 7434 ; 7435 e.trigger(); 7436 } catch (err) { 7437 if (!error) error = err; 7438 } 7439 } 7440 e = next; 7441 } 7442 } 7443 if (error) throw error; 7444} 7445function prepareDeps(sub) { 7446 for (let link = sub.deps; link; link = link.nextDep) { 7447 link.version = -1; 7448 link.prevActiveLink = link.dep.activeLink; 7449 link.dep.activeLink = link; 7450 } 7451} 7452function cleanupDeps(sub) { 7453 let head; 7454 let tail = sub.depsTail; 7455 let link = tail; 7456 while (link) { 7457 const prev = link.prevDep; 7458 if (link.version === -1) { 7459 if (link === tail) tail = prev; 7460 removeSub(link); 7461 removeDep(link); 7462 } else { 7463 head = link; 7464 } 7465 link.dep.activeLink = link.prevActiveLink; 7466 link.prevActiveLink = void 0; 7467 link = prev; 7468 } 7469 sub.deps = head; 7470 sub.depsTail = tail; 7471} 7472function isDirty(sub) { 7473 for (let link = sub.deps; link; link = link.nextDep) { 7474 if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) { 7475 return true; 7476 } 7477 } 7478 if (sub._dirty) { 7479 return true; 7480 } 7481 return false; 7482} 7483function refreshComputed(computed) { 7484 if (computed.flags & 4 && !(computed.flags & 16)) { 7485 return; 7486 } 7487 computed.flags &= ~16; 7488 if (computed.globalVersion === globalVersion) { 7489 return; 7490 } 7491 computed.globalVersion = globalVersion; 7492 const dep = computed.dep; 7493 computed.flags |= 2; 7494 if (dep.version > 0 && !computed.isSSR && computed.deps && !isDirty(computed)) { 7495 computed.flags &= ~2; 7496 return; 7497 } 7498 const prevSub = activeSub; 7499 const prevShouldTrack = shouldTrack; 7500 activeSub = computed; 7501 shouldTrack = true; 7502 try { 7503 prepareDeps(computed); 7504 const value = computed.fn(computed._value); 7505 if (dep.version === 0 || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(value, computed._value)) { 7506 computed._value = value; 7507 dep.version++; 7508 } 7509 } catch (err) { 7510 dep.version++; 7511 throw err; 7512 } finally { 7513 activeSub = prevSub; 7514 shouldTrack = prevShouldTrack; 7515 cleanupDeps(computed); 7516 computed.flags &= ~2; 7517 } 7518} 7519function removeSub(link, soft = false) { 7520 const { dep, prevSub, nextSub } = link; 7521 if (prevSub) { 7522 prevSub.nextSub = nextSub; 7523 link.prevSub = void 0; 7524 } 7525 if (nextSub) { 7526 nextSub.prevSub = prevSub; 7527 link.nextSub = void 0; 7528 } 7529 if ( true && dep.subsHead === link) { 7530 dep.subsHead = nextSub; 7531 } 7532 if (dep.subs === link) { 7533 dep.subs = prevSub; 7534 if (!prevSub && dep.computed) { 7535 dep.computed.flags &= ~4; 7536 for (let l = dep.computed.deps; l; l = l.nextDep) { 7537 removeSub(l, true); 7538 } 7539 } 7540 } 7541 if (!soft && !--dep.sc && dep.map) { 7542 dep.map.delete(dep.key); 7543 } 7544} 7545function removeDep(link) { 7546 const { prevDep, nextDep } = link; 7547 if (prevDep) { 7548 prevDep.nextDep = nextDep; 7549 link.prevDep = void 0; 7550 } 7551 if (nextDep) { 7552 nextDep.prevDep = prevDep; 7553 link.nextDep = void 0; 7554 } 7555} 7556function effect(fn, options) { 7557 if (fn.effect instanceof ReactiveEffect) { 7558 fn = fn.effect.fn; 7559 } 7560 const e = new ReactiveEffect(fn); 7561 if (options) { 7562 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)(e, options); 7563 } 7564 try { 7565 e.run(); 7566 } catch (err) { 7567 e.stop(); 7568 throw err; 7569 } 7570 const runner = e.run.bind(e); 7571 runner.effect = e; 7572 return runner; 7573} 7574function stop(runner) { 7575 runner.effect.stop(); 7576} 7577let shouldTrack = true; 7578const trackStack = []; 7579function pauseTracking() { 7580 trackStack.push(shouldTrack); 7581 shouldTrack = false; 7582} 7583function enableTracking() { 7584 trackStack.push(shouldTrack); 7585 shouldTrack = true; 7586} 7587function resetTracking() { 7588 const last = trackStack.pop(); 7589 shouldTrack = last === void 0 ? true : last; 7590} 7591function onEffectCleanup(fn, failSilently = false) { 7592 if (activeSub instanceof ReactiveEffect) { 7593 activeSub.cleanup = fn; 7594 } else if ( true && !failSilently) { 7595 warn( 7596 `onEffectCleanup() was called when there was no active effect to associate with.` 7597 ); 7598 } 7599} 7600function cleanupEffect(e) { 7601 const { cleanup } = e; 7602 e.cleanup = void 0; 7603 if (cleanup) { 7604 const prevSub = activeSub; 7605 activeSub = void 0; 7606 try { 7607 cleanup(); 7608 } finally { 7609 activeSub = prevSub; 7610 } 7611 } 7612} 7613 7614let globalVersion = 0; 7615class Link { 7616 constructor(sub, dep) { 7617 this.sub = sub; 7618 this.dep = dep; 7619 this.version = dep.version; 7620 this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0; 7621 } 7622} 7623class Dep { 7624 constructor(computed) { 7625 this.computed = computed; 7626 this.version = 0; 7627 /** 7628 * Link between this dep and the current active effect 7629 */ 7630 this.activeLink = void 0; 7631 /** 7632 * Doubly linked list representing the subscribing effects (tail) 7633 */ 7634 this.subs = void 0; 7635 /** 7636 * For object property deps cleanup 7637 */ 7638 this.map = void 0; 7639 this.key = void 0; 7640 /** 7641 * Subscriber counter 7642 */ 7643 this.sc = 0; 7644 if (true) { 7645 this.subsHead = void 0; 7646 } 7647 } 7648 track(debugInfo) { 7649 if (!activeSub || !shouldTrack || activeSub === this.computed) { 7650 return; 7651 } 7652 let link = this.activeLink; 7653 if (link === void 0 || link.sub !== activeSub) { 7654 link = this.activeLink = new Link(activeSub, this); 7655 if (!activeSub.deps) { 7656 activeSub.deps = activeSub.depsTail = link; 7657 } else { 7658 link.prevDep = activeSub.depsTail; 7659 activeSub.depsTail.nextDep = link; 7660 activeSub.depsTail = link; 7661 } 7662 addSub(link); 7663 } else if (link.version === -1) { 7664 link.version = this.version; 7665 if (link.nextDep) { 7666 const next = link.nextDep; 7667 next.prevDep = link.prevDep; 7668 if (link.prevDep) { 7669 link.prevDep.nextDep = next; 7670 } 7671 link.prevDep = activeSub.depsTail; 7672 link.nextDep = void 0; 7673 activeSub.depsTail.nextDep = link; 7674 activeSub.depsTail = link; 7675 if (activeSub.deps === link) { 7676 activeSub.deps = next; 7677 } 7678 } 7679 } 7680 if ( true && activeSub.onTrack) { 7681 activeSub.onTrack( 7682 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)( 7683 { 7684 effect: activeSub 7685 }, 7686 debugInfo 7687 ) 7688 ); 7689 } 7690 return link; 7691 } 7692 trigger(debugInfo) { 7693 this.version++; 7694 globalVersion++; 7695 this.notify(debugInfo); 7696 } 7697 notify(debugInfo) { 7698 startBatch(); 7699 try { 7700 if (true) { 7701 for (let head = this.subsHead; head; head = head.nextSub) { 7702 if (head.sub.onTrigger && !(head.sub.flags & 8)) { 7703 head.sub.onTrigger( 7704 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)( 7705 { 7706 effect: head.sub 7707 }, 7708 debugInfo 7709 ) 7710 ); 7711 } 7712 } 7713 } 7714 for (let link = this.subs; link; link = link.prevSub) { 7715 if (link.sub.notify()) { 7716 ; 7717 link.sub.dep.notify(); 7718 } 7719 } 7720 } finally { 7721 endBatch(); 7722 } 7723 } 7724} 7725function addSub(link) { 7726 link.dep.sc++; 7727 if (link.sub.flags & 4) { 7728 const computed = link.dep.computed; 7729 if (computed && !link.dep.subs) { 7730 computed.flags |= 4 | 16; 7731 for (let l = computed.deps; l; l = l.nextDep) { 7732 addSub(l); 7733 } 7734 } 7735 const currentTail = link.dep.subs; 7736 if (currentTail !== link) { 7737 link.prevSub = currentTail; 7738 if (currentTail) currentTail.nextSub = link; 7739 } 7740 if ( true && link.dep.subsHead === void 0) { 7741 link.dep.subsHead = link; 7742 } 7743 link.dep.subs = link; 7744 } 7745} 7746const targetMap = /* @__PURE__ */ new WeakMap(); 7747const ITERATE_KEY = Symbol( 7748 true ? "Object iterate" : 0 7749); 7750const MAP_KEY_ITERATE_KEY = Symbol( 7751 true ? "Map keys iterate" : 0 7752); 7753const ARRAY_ITERATE_KEY = Symbol( 7754 true ? "Array iterate" : 0 7755); 7756function track(target, type, key) { 7757 if (shouldTrack && activeSub) { 7758 let depsMap = targetMap.get(target); 7759 if (!depsMap) { 7760 targetMap.set(target, depsMap = /* @__PURE__ */ new Map()); 7761 } 7762 let dep = depsMap.get(key); 7763 if (!dep) { 7764 depsMap.set(key, dep = new Dep()); 7765 dep.map = depsMap; 7766 dep.key = key; 7767 } 7768 if (true) { 7769 dep.track({ 7770 target, 7771 type, 7772 key 7773 }); 7774 } else {} 7775 } 7776} 7777function trigger(target, type, key, newValue, oldValue, oldTarget) { 7778 const depsMap = targetMap.get(target); 7779 if (!depsMap) { 7780 globalVersion++; 7781 return; 7782 } 7783 const run = (dep) => { 7784 if (dep) { 7785 if (true) { 7786 dep.trigger({ 7787 target, 7788 type, 7789 key, 7790 newValue, 7791 oldValue, 7792 oldTarget 7793 }); 7794 } else {} 7795 } 7796 }; 7797 startBatch(); 7798 if (type === "clear") { 7799 depsMap.forEach(run); 7800 } else { 7801 const targetIsArray = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target); 7802 const isArrayIndex = targetIsArray && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isIntegerKey)(key); 7803 if (targetIsArray && key === "length") { 7804 const newLength = Number(newValue); 7805 depsMap.forEach((dep, key2) => { 7806 if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(key2) && key2 >= newLength) { 7807 run(dep); 7808 } 7809 }); 7810 } else { 7811 if (key !== void 0 || depsMap.has(void 0)) { 7812 run(depsMap.get(key)); 7813 } 7814 if (isArrayIndex) { 7815 run(depsMap.get(ARRAY_ITERATE_KEY)); 7816 } 7817 switch (type) { 7818 case "add": 7819 if (!targetIsArray) { 7820 run(depsMap.get(ITERATE_KEY)); 7821 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target)) { 7822 run(depsMap.get(MAP_KEY_ITERATE_KEY)); 7823 } 7824 } else if (isArrayIndex) { 7825 run(depsMap.get("length")); 7826 } 7827 break; 7828 case "delete": 7829 if (!targetIsArray) { 7830 run(depsMap.get(ITERATE_KEY)); 7831 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target)) { 7832 run(depsMap.get(MAP_KEY_ITERATE_KEY)); 7833 } 7834 } 7835 break; 7836 case "set": 7837 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target)) { 7838 run(depsMap.get(ITERATE_KEY)); 7839 } 7840 break; 7841 } 7842 } 7843 } 7844 endBatch(); 7845} 7846function getDepFromReactive(object, key) { 7847 const depMap = targetMap.get(object); 7848 return depMap && depMap.get(key); 7849} 7850 7851function reactiveReadArray(array) { 7852 const raw = toRaw(array); 7853 if (raw === array) return raw; 7854 track(raw, "iterate", ARRAY_ITERATE_KEY); 7855 return isShallow(array) ? raw : raw.map(toReactive); 7856} 7857function shallowReadArray(arr) { 7858 track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY); 7859 return arr; 7860} 7861const arrayInstrumentations = { 7862 __proto__: null, 7863 [Symbol.iterator]() { 7864 return iterator(this, Symbol.iterator, toReactive); 7865 }, 7866 concat(...args) { 7867 return reactiveReadArray(this).concat( 7868 ...args.map((x) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(x) ? reactiveReadArray(x) : x) 7869 ); 7870 }, 7871 entries() { 7872 return iterator(this, "entries", (value) => { 7873 value[1] = toReactive(value[1]); 7874 return value; 7875 }); 7876 }, 7877 every(fn, thisArg) { 7878 return apply(this, "every", fn, thisArg, void 0, arguments); 7879 }, 7880 filter(fn, thisArg) { 7881 return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive), arguments); 7882 }, 7883 find(fn, thisArg) { 7884 return apply(this, "find", fn, thisArg, toReactive, arguments); 7885 }, 7886 findIndex(fn, thisArg) { 7887 return apply(this, "findIndex", fn, thisArg, void 0, arguments); 7888 }, 7889 findLast(fn, thisArg) { 7890 return apply(this, "findLast", fn, thisArg, toReactive, arguments); 7891 }, 7892 findLastIndex(fn, thisArg) { 7893 return apply(this, "findLastIndex", fn, thisArg, void 0, arguments); 7894 }, 7895 // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement 7896 forEach(fn, thisArg) { 7897 return apply(this, "forEach", fn, thisArg, void 0, arguments); 7898 }, 7899 includes(...args) { 7900 return searchProxy(this, "includes", args); 7901 }, 7902 indexOf(...args) { 7903 return searchProxy(this, "indexOf", args); 7904 }, 7905 join(separator) { 7906 return reactiveReadArray(this).join(separator); 7907 }, 7908 // keys() iterator only reads `length`, no optimisation required 7909 lastIndexOf(...args) { 7910 return searchProxy(this, "lastIndexOf", args); 7911 }, 7912 map(fn, thisArg) { 7913 return apply(this, "map", fn, thisArg, void 0, arguments); 7914 }, 7915 pop() { 7916 return noTracking(this, "pop"); 7917 }, 7918 push(...args) { 7919 return noTracking(this, "push", args); 7920 }, 7921 reduce(fn, ...args) { 7922 return reduce(this, "reduce", fn, args); 7923 }, 7924 reduceRight(fn, ...args) { 7925 return reduce(this, "reduceRight", fn, args); 7926 }, 7927 shift() { 7928 return noTracking(this, "shift"); 7929 }, 7930 // slice could use ARRAY_ITERATE but also seems to beg for range tracking 7931 some(fn, thisArg) { 7932 return apply(this, "some", fn, thisArg, void 0, arguments); 7933 }, 7934 splice(...args) { 7935 return noTracking(this, "splice", args); 7936 }, 7937 toReversed() { 7938 return reactiveReadArray(this).toReversed(); 7939 }, 7940 toSorted(comparer) { 7941 return reactiveReadArray(this).toSorted(comparer); 7942 }, 7943 toSpliced(...args) { 7944 return reactiveReadArray(this).toSpliced(...args); 7945 }, 7946 unshift(...args) { 7947 return noTracking(this, "unshift", args); 7948 }, 7949 values() { 7950 return iterator(this, "values", toReactive); 7951 } 7952}; 7953function iterator(self, method, wrapValue) { 7954 const arr = shallowReadArray(self); 7955 const iter = arr[method](); 7956 if (arr !== self && !isShallow(self)) { 7957 iter._next = iter.next; 7958 iter.next = () => { 7959 const result = iter._next(); 7960 if (result.value) { 7961 result.value = wrapValue(result.value); 7962 } 7963 return result; 7964 }; 7965 } 7966 return iter; 7967} 7968const arrayProto = Array.prototype; 7969function apply(self, method, fn, thisArg, wrappedRetFn, args) { 7970 const arr = shallowReadArray(self); 7971 const needsWrap = arr !== self && !isShallow(self); 7972 const methodFn = arr[method]; 7973 if (methodFn !== arrayProto[method]) { 7974 const result2 = methodFn.apply(self, args); 7975 return needsWrap ? toReactive(result2) : result2; 7976 } 7977 let wrappedFn = fn; 7978 if (arr !== self) { 7979 if (needsWrap) { 7980 wrappedFn = function(item, index) { 7981 return fn.call(this, toReactive(item), index, self); 7982 }; 7983 } else if (fn.length > 2) { 7984 wrappedFn = function(item, index) { 7985 return fn.call(this, item, index, self); 7986 }; 7987 } 7988 } 7989 const result = methodFn.call(arr, wrappedFn, thisArg); 7990 return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result; 7991} 7992function reduce(self, method, fn, args) { 7993 const arr = shallowReadArray(self); 7994 let wrappedFn = fn; 7995 if (arr !== self) { 7996 if (!isShallow(self)) { 7997 wrappedFn = function(acc, item, index) { 7998 return fn.call(this, acc, toReactive(item), index, self); 7999 }; 8000 } else if (fn.length > 3) { 8001 wrappedFn = function(acc, item, index) { 8002 return fn.call(this, acc, item, index, self); 8003 }; 8004 } 8005 } 8006 return arr[method](wrappedFn, ...args); 8007} 8008function searchProxy(self, method, args) { 8009 const arr = toRaw(self); 8010 track(arr, "iterate", ARRAY_ITERATE_KEY); 8011 const res = arr[method](...args); 8012 if ((res === -1 || res === false) && isProxy(args[0])) { 8013 args[0] = toRaw(args[0]); 8014 return arr[method](...args); 8015 } 8016 return res; 8017} 8018function noTracking(self, method, args = []) { 8019 pauseTracking(); 8020 startBatch(); 8021 const res = toRaw(self)[method].apply(self, args); 8022 endBatch(); 8023 resetTracking(); 8024 return res; 8025} 8026 8027const isNonTrackableKeys = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.makeMap)(`__proto__,__v_isRef,__isVue`); 8028const builtInSymbols = new Set( 8029 /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol) 8030); 8031function hasOwnProperty(key) { 8032 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(key)) key = String(key); 8033 const obj = toRaw(this); 8034 track(obj, "has", key); 8035 return obj.hasOwnProperty(key); 8036} 8037class BaseReactiveHandler { 8038 constructor(_isReadonly = false, _isShallow = false) { 8039 this._isReadonly = _isReadonly; 8040 this._isShallow = _isShallow; 8041 } 8042 get(target, key, receiver) { 8043 if (key === "__v_skip") return target["__v_skip"]; 8044 const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow; 8045 if (key === "__v_isReactive") { 8046 return !isReadonly2; 8047 } else if (key === "__v_isReadonly") { 8048 return isReadonly2; 8049 } else if (key === "__v_isShallow") { 8050 return isShallow2; 8051 } else if (key === "__v_raw") { 8052 if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype 8053 // this means the receiver is a user proxy of the reactive proxy 8054 Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) { 8055 return target; 8056 } 8057 return; 8058 } 8059 const targetIsArray = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target); 8060 if (!isReadonly2) { 8061 let fn; 8062 if (targetIsArray && (fn = arrayInstrumentations[key])) { 8063 return fn; 8064 } 8065 if (key === "hasOwnProperty") { 8066 return hasOwnProperty; 8067 } 8068 } 8069 const res = Reflect.get( 8070 target, 8071 key, 8072 // if this is a proxy wrapping a ref, return methods using the raw ref 8073 // as receiver so that we don't have to call `toRaw` on the ref in all 8074 // its class methods 8075 isRef(target) ? target : receiver 8076 ); 8077 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { 8078 return res; 8079 } 8080 if (!isReadonly2) { 8081 track(target, "get", key); 8082 } 8083 if (isShallow2) { 8084 return res; 8085 } 8086 if (isRef(res)) { 8087 return targetIsArray && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isIntegerKey)(key) ? res : res.value; 8088 } 8089 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(res)) { 8090 return isReadonly2 ? readonly(res) : reactive(res); 8091 } 8092 return res; 8093 } 8094} 8095class MutableReactiveHandler extends BaseReactiveHandler { 8096 constructor(isShallow2 = false) { 8097 super(false, isShallow2); 8098 } 8099 set(target, key, value, receiver) { 8100 let oldValue = target[key]; 8101 if (!this._isShallow) { 8102 const isOldValueReadonly = isReadonly(oldValue); 8103 if (!isShallow(value) && !isReadonly(value)) { 8104 oldValue = toRaw(oldValue); 8105 value = toRaw(value); 8106 } 8107 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target) && isRef(oldValue) && !isRef(value)) { 8108 if (isOldValueReadonly) { 8109 return false; 8110 } else { 8111 oldValue.value = value; 8112 return true; 8113 } 8114 } 8115 } 8116 const hadKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isIntegerKey)(key) ? Number(key) < target.length : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(target, key); 8117 const result = Reflect.set( 8118 target, 8119 key, 8120 value, 8121 isRef(target) ? target : receiver 8122 ); 8123 if (target === toRaw(receiver)) { 8124 if (!hadKey) { 8125 trigger(target, "add", key, value); 8126 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(value, oldValue)) { 8127 trigger(target, "set", key, value, oldValue); 8128 } 8129 } 8130 return result; 8131 } 8132 deleteProperty(target, key) { 8133 const hadKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(target, key); 8134 const oldValue = target[key]; 8135 const result = Reflect.deleteProperty(target, key); 8136 if (result && hadKey) { 8137 trigger(target, "delete", key, void 0, oldValue); 8138 } 8139 return result; 8140 } 8141 has(target, key) { 8142 const result = Reflect.has(target, key); 8143 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(key) || !builtInSymbols.has(key)) { 8144 track(target, "has", key); 8145 } 8146 return result; 8147 } 8148 ownKeys(target) { 8149 track( 8150 target, 8151 "iterate", 8152 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target) ? "length" : ITERATE_KEY 8153 ); 8154 return Reflect.ownKeys(target); 8155 } 8156} 8157class ReadonlyReactiveHandler extends BaseReactiveHandler { 8158 constructor(isShallow2 = false) { 8159 super(true, isShallow2); 8160 } 8161 set(target, key) { 8162 if (true) { 8163 warn( 8164 `Set operation on key "${String(key)}" failed: target is readonly.`, 8165 target 8166 ); 8167 } 8168 return true; 8169 } 8170 deleteProperty(target, key) { 8171 if (true) { 8172 warn( 8173 `Delete operation on key "${String(key)}" failed: target is readonly.`, 8174 target 8175 ); 8176 } 8177 return true; 8178 } 8179} 8180const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler(); 8181const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(); 8182const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true); 8183const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true); 8184 8185const toShallow = (value) => value; 8186const getProto = (v) => Reflect.getPrototypeOf(v); 8187function createIterableMethod(method, isReadonly2, isShallow2) { 8188 return function(...args) { 8189 const target = this["__v_raw"]; 8190 const rawTarget = toRaw(target); 8191 const targetIsMap = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(rawTarget); 8192 const isPair = method === "entries" || method === Symbol.iterator && targetIsMap; 8193 const isKeyOnly = method === "keys" && targetIsMap; 8194 const innerIterator = target[method](...args); 8195 const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive; 8196 !isReadonly2 && track( 8197 rawTarget, 8198 "iterate", 8199 isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY 8200 ); 8201 return { 8202 // iterator protocol 8203 next() { 8204 const { value, done } = innerIterator.next(); 8205 return done ? { value, done } : { 8206 value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), 8207 done 8208 }; 8209 }, 8210 // iterable protocol 8211 [Symbol.iterator]() { 8212 return this; 8213 } 8214 }; 8215 }; 8216} 8217function createReadonlyMethod(type) { 8218 return function(...args) { 8219 if (true) { 8220 const key = args[0] ? `on key "${args[0]}" ` : ``; 8221 warn( 8222 `${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.capitalize)(type)} operation ${key}failed: target is readonly.`, 8223 toRaw(this) 8224 ); 8225 } 8226 return type === "delete" ? false : type === "clear" ? void 0 : this; 8227 }; 8228} 8229function createInstrumentations(readonly, shallow) { 8230 const instrumentations = { 8231 get(key) { 8232 const target = this["__v_raw"]; 8233 const rawTarget = toRaw(target); 8234 const rawKey = toRaw(key); 8235 if (!readonly) { 8236 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(key, rawKey)) { 8237 track(rawTarget, "get", key); 8238 } 8239 track(rawTarget, "get", rawKey); 8240 } 8241 const { has } = getProto(rawTarget); 8242 const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive; 8243 if (has.call(rawTarget, key)) { 8244 return wrap(target.get(key)); 8245 } else if (has.call(rawTarget, rawKey)) { 8246 return wrap(target.get(rawKey)); 8247 } else if (target !== rawTarget) { 8248 target.get(key); 8249 } 8250 }, 8251 get size() { 8252 const target = this["__v_raw"]; 8253 !readonly && track(toRaw(target), "iterate", ITERATE_KEY); 8254 return Reflect.get(target, "size", target); 8255 }, 8256 has(key) { 8257 const target = this["__v_raw"]; 8258 const rawTarget = toRaw(target); 8259 const rawKey = toRaw(key); 8260 if (!readonly) { 8261 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(key, rawKey)) { 8262 track(rawTarget, "has", key); 8263 } 8264 track(rawTarget, "has", rawKey); 8265 } 8266 return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); 8267 }, 8268 forEach(callback, thisArg) { 8269 const observed = this; 8270 const target = observed["__v_raw"]; 8271 const rawTarget = toRaw(target); 8272 const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive; 8273 !readonly && track(rawTarget, "iterate", ITERATE_KEY); 8274 return target.forEach((value, key) => { 8275 return callback.call(thisArg, wrap(value), wrap(key), observed); 8276 }); 8277 } 8278 }; 8279 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)( 8280 instrumentations, 8281 readonly ? { 8282 add: createReadonlyMethod("add"), 8283 set: createReadonlyMethod("set"), 8284 delete: createReadonlyMethod("delete"), 8285 clear: createReadonlyMethod("clear") 8286 } : { 8287 add(value) { 8288 if (!shallow && !isShallow(value) && !isReadonly(value)) { 8289 value = toRaw(value); 8290 } 8291 const target = toRaw(this); 8292 const proto = getProto(target); 8293 const hadKey = proto.has.call(target, value); 8294 if (!hadKey) { 8295 target.add(value); 8296 trigger(target, "add", value, value); 8297 } 8298 return this; 8299 }, 8300 set(key, value) { 8301 if (!shallow && !isShallow(value) && !isReadonly(value)) { 8302 value = toRaw(value); 8303 } 8304 const target = toRaw(this); 8305 const { has, get } = getProto(target); 8306 let hadKey = has.call(target, key); 8307 if (!hadKey) { 8308 key = toRaw(key); 8309 hadKey = has.call(target, key); 8310 } else if (true) { 8311 checkIdentityKeys(target, has, key); 8312 } 8313 const oldValue = get.call(target, key); 8314 target.set(key, value); 8315 if (!hadKey) { 8316 trigger(target, "add", key, value); 8317 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(value, oldValue)) { 8318 trigger(target, "set", key, value, oldValue); 8319 } 8320 return this; 8321 }, 8322 delete(key) { 8323 const target = toRaw(this); 8324 const { has, get } = getProto(target); 8325 let hadKey = has.call(target, key); 8326 if (!hadKey) { 8327 key = toRaw(key); 8328 hadKey = has.call(target, key); 8329 } else if (true) { 8330 checkIdentityKeys(target, has, key); 8331 } 8332 const oldValue = get ? get.call(target, key) : void 0; 8333 const result = target.delete(key); 8334 if (hadKey) { 8335 trigger(target, "delete", key, void 0, oldValue); 8336 } 8337 return result; 8338 }, 8339 clear() { 8340 const target = toRaw(this); 8341 const hadItems = target.size !== 0; 8342 const oldTarget = true ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target) ? new Map(target) : new Set(target) : 0; 8343 const result = target.clear(); 8344 if (hadItems) { 8345 trigger( 8346 target, 8347 "clear", 8348 void 0, 8349 void 0, 8350 oldTarget 8351 ); 8352 } 8353 return result; 8354 } 8355 } 8356 ); 8357 const iteratorMethods = [ 8358 "keys", 8359 "values", 8360 "entries", 8361 Symbol.iterator 8362 ]; 8363 iteratorMethods.forEach((method) => { 8364 instrumentations[method] = createIterableMethod(method, readonly, shallow); 8365 }); 8366 return instrumentations; 8367} 8368function createInstrumentationGetter(isReadonly2, shallow) { 8369 const instrumentations = createInstrumentations(isReadonly2, shallow); 8370 return (target, key, receiver) => { 8371 if (key === "__v_isReactive") { 8372 return !isReadonly2; 8373 } else if (key === "__v_isReadonly") { 8374 return isReadonly2; 8375 } else if (key === "__v_raw") { 8376 return target; 8377 } 8378 return Reflect.get( 8379 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(instrumentations, key) && key in target ? instrumentations : target, 8380 key, 8381 receiver 8382 ); 8383 }; 8384} 8385const mutableCollectionHandlers = { 8386 get: /* @__PURE__ */ createInstrumentationGetter(false, false) 8387}; 8388const shallowCollectionHandlers = { 8389 get: /* @__PURE__ */ createInstrumentationGetter(false, true) 8390}; 8391const readonlyCollectionHandlers = { 8392 get: /* @__PURE__ */ createInstrumentationGetter(true, false) 8393}; 8394const shallowReadonlyCollectionHandlers = { 8395 get: /* @__PURE__ */ createInstrumentationGetter(true, true) 8396}; 8397function checkIdentityKeys(target, has, key) { 8398 const rawKey = toRaw(key); 8399 if (rawKey !== key && has.call(target, rawKey)) { 8400 const type = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.toRawType)(target); 8401 warn( 8402 `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.` 8403 ); 8404 } 8405} 8406 8407const reactiveMap = /* @__PURE__ */ new WeakMap(); 8408const shallowReactiveMap = /* @__PURE__ */ new WeakMap(); 8409const readonlyMap = /* @__PURE__ */ new WeakMap(); 8410const shallowReadonlyMap = /* @__PURE__ */ new WeakMap(); 8411function targetTypeMap(rawType) { 8412 switch (rawType) { 8413 case "Object": 8414 case "Array": 8415 return 1 /* COMMON */; 8416 case "Map": 8417 case "Set": 8418 case "WeakMap": 8419 case "WeakSet": 8420 return 2 /* COLLECTION */; 8421 default: 8422 return 0 /* INVALID */; 8423 } 8424} 8425function getTargetType(value) { 8426 return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.toRawType)(value)); 8427} 8428function reactive(target) { 8429 if (isReadonly(target)) { 8430 return target; 8431 } 8432 return createReactiveObject( 8433 target, 8434 false, 8435 mutableHandlers, 8436 mutableCollectionHandlers, 8437 reactiveMap 8438 ); 8439} 8440function shallowReactive(target) { 8441 return createReactiveObject( 8442 target, 8443 false, 8444 shallowReactiveHandlers, 8445 shallowCollectionHandlers, 8446 shallowReactiveMap 8447 ); 8448} 8449function readonly(target) { 8450 return createReactiveObject( 8451 target, 8452 true, 8453 readonlyHandlers, 8454 readonlyCollectionHandlers, 8455 readonlyMap 8456 ); 8457} 8458function shallowReadonly(target) { 8459 return createReactiveObject( 8460 target, 8461 true, 8462 shallowReadonlyHandlers, 8463 shallowReadonlyCollectionHandlers, 8464 shallowReadonlyMap 8465 ); 8466} 8467function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) { 8468 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(target)) { 8469 if (true) { 8470 warn( 8471 `value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String( 8472 target 8473 )}` 8474 ); 8475 } 8476 return target; 8477 } 8478 if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) { 8479 return target; 8480 } 8481 const existingProxy = proxyMap.get(target); 8482 if (existingProxy) { 8483 return existingProxy; 8484 } 8485 const targetType = getTargetType(target); 8486 if (targetType === 0 /* INVALID */) { 8487 return target; 8488 } 8489 const proxy = new Proxy( 8490 target, 8491 targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers 8492 ); 8493 proxyMap.set(target, proxy); 8494 return proxy; 8495} 8496function isReactive(value) { 8497 if (isReadonly(value)) { 8498 return isReactive(value["__v_raw"]); 8499 } 8500 return !!(value && value["__v_isReactive"]); 8501} 8502function isReadonly(value) { 8503 return !!(value && value["__v_isReadonly"]); 8504} 8505function isShallow(value) { 8506 return !!(value && value["__v_isShallow"]); 8507} 8508function isProxy(value) { 8509 return value ? !!value["__v_raw"] : false; 8510} 8511function toRaw(observed) { 8512 const raw = observed && observed["__v_raw"]; 8513 return raw ? toRaw(raw) : observed; 8514} 8515function markRaw(value) { 8516 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(value, "__v_skip") && Object.isExtensible(value)) { 8517 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.def)(value, "__v_skip", true); 8518 } 8519 return value; 8520} 8521const toReactive = (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(value) ? reactive(value) : value; 8522const toReadonly = (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(value) ? readonly(value) : value; 8523 8524function isRef(r) { 8525 return r ? r["__v_isRef"] === true : false; 8526} 8527function ref(value) { 8528 return createRef(value, false); 8529} 8530function shallowRef(value) { 8531 return createRef(value, true); 8532} 8533function createRef(rawValue, shallow) { 8534 if (isRef(rawValue)) { 8535 return rawValue; 8536 } 8537 return new RefImpl(rawValue, shallow); 8538} 8539class RefImpl { 8540 constructor(value, isShallow2) { 8541 this.dep = new Dep(); 8542 this["__v_isRef"] = true; 8543 this["__v_isShallow"] = false; 8544 this._rawValue = isShallow2 ? value : toRaw(value); 8545 this._value = isShallow2 ? value : toReactive(value); 8546 this["__v_isShallow"] = isShallow2; 8547 } 8548 get value() { 8549 if (true) { 8550 this.dep.track({ 8551 target: this, 8552 type: "get", 8553 key: "value" 8554 }); 8555 } else {} 8556 return this._value; 8557 } 8558 set value(newValue) { 8559 const oldValue = this._rawValue; 8560 const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue); 8561 newValue = useDirectValue ? newValue : toRaw(newValue); 8562 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(newValue, oldValue)) { 8563 this._rawValue = newValue; 8564 this._value = useDirectValue ? newValue : toReactive(newValue); 8565 if (true) { 8566 this.dep.trigger({ 8567 target: this, 8568 type: "set", 8569 key: "value", 8570 newValue, 8571 oldValue 8572 }); 8573 } else {} 8574 } 8575 } 8576} 8577function triggerRef(ref2) { 8578 if (ref2.dep) { 8579 if (true) { 8580 ref2.dep.trigger({ 8581 target: ref2, 8582 type: "set", 8583 key: "value", 8584 newValue: ref2._value 8585 }); 8586 } else {} 8587 } 8588} 8589function unref(ref2) { 8590 return isRef(ref2) ? ref2.value : ref2; 8591} 8592function toValue(source) { 8593 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isFunction)(source) ? source() : unref(source); 8594} 8595const shallowUnwrapHandlers = { 8596 get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)), 8597 set: (target, key, value, receiver) => { 8598 const oldValue = target[key]; 8599 if (isRef(oldValue) && !isRef(value)) { 8600 oldValue.value = value; 8601 return true; 8602 } else { 8603 return Reflect.set(target, key, value, receiver); 8604 } 8605 } 8606}; 8607function proxyRefs(objectWithRefs) { 8608 return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers); 8609} 8610class CustomRefImpl { 8611 constructor(factory) { 8612 this["__v_isRef"] = true; 8613 this._value = void 0; 8614 const dep = this.dep = new Dep(); 8615 const { get, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep)); 8616 this._get = get; 8617 this._set = set; 8618 } 8619 get value() { 8620 return this._value = this._get(); 8621 } 8622 set value(newVal) { 8623 this._set(newVal); 8624 } 8625} 8626function customRef(factory) { 8627 return new CustomRefImpl(factory); 8628} 8629function toRefs(object) { 8630 if ( true && !isProxy(object)) { 8631 warn(`toRefs() expects a reactive object but received a plain one.`); 8632 } 8633 const ret = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(object) ? new Array(object.length) : {}; 8634 for (const key in object) { 8635 ret[key] = propertyToRef(object, key); 8636 } 8637 return ret; 8638} 8639class ObjectRefImpl { 8640 constructor(_object, _key, _defaultValue) { 8641 this._object = _object; 8642 this._key = _key; 8643 this._defaultValue = _defaultValue; 8644 this["__v_isRef"] = true; 8645 this._value = void 0; 8646 } 8647 get value() { 8648 const val = this._object[this._key]; 8649 return this._value = val === void 0 ? this._defaultValue : val; 8650 } 8651 set value(newVal) { 8652 this._object[this._key] = newVal; 8653 } 8654 get dep() { 8655 return getDepFromReactive(toRaw(this._object), this._key); 8656 } 8657} 8658class GetterRefImpl { 8659 constructor(_getter) { 8660 this._getter = _getter; 8661 this["__v_isRef"] = true; 8662 this["__v_isReadonly"] = true; 8663 this._value = void 0; 8664 } 8665 get value() { 8666 return this._value = this._getter(); 8667 } 8668} 8669function toRef(source, key, defaultValue) { 8670 if (isRef(source)) { 8671 return source; 8672 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isFunction)(source)) { 8673 return new GetterRefImpl(source); 8674 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(source) && arguments.length > 1) { 8675 return propertyToRef(source, key, defaultValue); 8676 } else { 8677 return ref(source); 8678 } 8679} 8680function propertyToRef(source, key, defaultValue) { 8681 const val = source[key]; 8682 return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue); 8683} 8684 8685class ComputedRefImpl { 8686 constructor(fn, setter, isSSR) { 8687 this.fn = fn; 8688 this.setter = setter; 8689 /** 8690 * @internal 8691 */ 8692 this._value = void 0; 8693 /** 8694 * @internal 8695 */ 8696 this.dep = new Dep(this); 8697 /** 8698 * @internal 8699 */ 8700 this.__v_isRef = true; 8701 // TODO isolatedDeclarations "__v_isReadonly" 8702 // A computed is also a subscriber that tracks other deps 8703 /** 8704 * @internal 8705 */ 8706 this.deps = void 0; 8707 /** 8708 * @internal 8709 */ 8710 this.depsTail = void 0; 8711 /** 8712 * @internal 8713 */ 8714 this.flags = 16; 8715 /** 8716 * @internal 8717 */ 8718 this.globalVersion = globalVersion - 1; 8719 /** 8720 * @internal 8721 */ 8722 this.next = void 0; 8723 // for backwards compat 8724 this.effect = this; 8725 this["__v_isReadonly"] = !setter; 8726 this.isSSR = isSSR; 8727 } 8728 /** 8729 * @internal 8730 */ 8731 notify() { 8732 this.flags |= 16; 8733 if (!(this.flags & 8) && // avoid infinite self recursion 8734 activeSub !== this) { 8735 batch(this, true); 8736 return true; 8737 } else if (true) ; 8738 } 8739 get value() { 8740 const link = true ? this.dep.track({ 8741 target: this, 8742 type: "get", 8743 key: "value" 8744 }) : 0; 8745 refreshComputed(this); 8746 if (link) { 8747 link.version = this.dep.version; 8748 } 8749 return this._value; 8750 } 8751 set value(newValue) { 8752 if (this.setter) { 8753 this.setter(newValue); 8754 } else if (true) { 8755 warn("Write operation failed: computed value is readonly"); 8756 } 8757 } 8758} 8759function computed(getterOrOptions, debugOptions, isSSR = false) { 8760 let getter; 8761 let setter; 8762 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isFunction)(getterOrOptions)) { 8763 getter = getterOrOptions; 8764 } else { 8765 getter = getterOrOptions.get; 8766 setter = getterOrOptions.set; 8767 } 8768 const cRef = new ComputedRefImpl(getter, setter, isSSR); 8769 if ( true && debugOptions && !isSSR) { 8770 cRef.onTrack = debugOptions.onTrack; 8771 cRef.onTrigger = debugOptions.onTrigger; 8772 } 8773 return cRef; 8774} 8775 8776const TrackOpTypes = { 8777 "GET": "get", 8778 "HAS": "has", 8779 "ITERATE": "iterate" 8780}; 8781const TriggerOpTypes = { 8782 "SET": "set", 8783 "ADD": "add", 8784 "DELETE": "delete", 8785 "CLEAR": "clear" 8786}; 8787const ReactiveFlags = { 8788 "SKIP": "__v_skip", 8789 "IS_REACTIVE": "__v_isReactive", 8790 "IS_READONLY": "__v_isReadonly", 8791 "IS_SHALLOW": "__v_isShallow", 8792 "RAW": "__v_raw", 8793 "IS_REF": "__v_isRef" 8794}; 8795 8796const WatchErrorCodes = { 8797 "WATCH_GETTER": 2, 8798 "2": "WATCH_GETTER", 8799 "WATCH_CALLBACK": 3, 8800 "3": "WATCH_CALLBACK", 8801 "WATCH_CLEANUP": 4, 8802 "4": "WATCH_CLEANUP" 8803}; 8804const INITIAL_WATCHER_VALUE = {}; 8805const cleanupMap = /* @__PURE__ */ new WeakMap(); 8806let activeWatcher = void 0; 8807function getCurrentWatcher() { 8808 return activeWatcher; 8809} 8810function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) { 8811 if (owner) { 8812 let cleanups = cleanupMap.get(owner); 8813 if (!cleanups) cleanupMap.set(owner, cleanups = []); 8814 cleanups.push(cleanupFn); 8815 } else if ( true && !failSilently) { 8816 warn( 8817 `onWatcherCleanup() was called when there was no active watcher to associate with.` 8818 ); 8819 } 8820} 8821function watch(source, cb, options = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.EMPTY_OBJ) { 8822 const { immediate, deep, once, scheduler, augmentJob, call } = options; 8823 const warnInvalidSource = (s) => { 8824 (options.onWarn || warn)( 8825 `Invalid watch source: `, 8826 s, 8827 `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.` 8828 ); 8829 }; 8830 const reactiveGetter = (source2) => { 8831 if (deep) return source2; 8832 if (isShallow(source2) || deep === false || deep === 0) 8833 return traverse(source2, 1); 8834 return traverse(source2); 8835 }; 8836 let effect; 8837 let getter; 8838 let cleanup; 8839 let boundCleanup; 8840 let forceTrigger = false; 8841 let isMultiSource = false; 8842 if (isRef(source)) { 8843 getter = () => source.value; 8844 forceTrigger = isShallow(source); 8845 } else if (isReactive(source)) { 8846 getter = () => reactiveGetter(source); 8847 forceTrigger = true; 8848 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(source)) { 8849 isMultiSource = true; 8850 forceTrigger = source.some((s) => isReactive(s) || isShallow(s)); 8851 getter = () => source.map((s) => { 8852 if (isRef(s)) { 8853 return s.value; 8854 } else if (isReactive(s)) { 8855 return reactiveGetter(s); 8856 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isFunction)(s)) { 8857 return call ? call(s, 2) : s(); 8858 } else { 8859 true && warnInvalidSource(s); 8860 } 8861 }); 8862 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isFunction)(source)) { 8863 if (cb) { 8864 getter = call ? () => call(source, 2) : source; 8865 } else { 8866 getter = () => { 8867 if (cleanup) { 8868 pauseTracking(); 8869 try { 8870 cleanup(); 8871 } finally { 8872 resetTracking(); 8873 } 8874 } 8875 const currentEffect = activeWatcher; 8876 activeWatcher = effect; 8877 try { 8878 return call ? call(source, 3, [boundCleanup]) : source(boundCleanup); 8879 } finally { 8880 activeWatcher = currentEffect; 8881 } 8882 }; 8883 } 8884 } else { 8885 getter = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP; 8886 true && warnInvalidSource(source); 8887 } 8888 if (cb && deep) { 8889 const baseGetter = getter; 8890 const depth = deep === true ? Infinity : deep; 8891 getter = () => traverse(baseGetter(), depth); 8892 } 8893 const scope = getCurrentScope(); 8894 const watchHandle = () => { 8895 effect.stop(); 8896 if (scope && scope.active) { 8897 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.remove)(scope.effects, effect); 8898 } 8899 }; 8900 if (once && cb) { 8901 const _cb = cb; 8902 cb = (...args) => { 8903 _cb(...args); 8904 watchHandle(); 8905 }; 8906 } 8907 let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE; 8908 const job = (immediateFirstRun) => { 8909 if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) { 8910 return; 8911 } 8912 if (cb) { 8913 const newValue = effect.run(); 8914 if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(v, oldValue[i])) : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(newValue, oldValue))) { 8915 if (cleanup) { 8916 cleanup(); 8917 } 8918 const currentWatcher = activeWatcher; 8919 activeWatcher = effect; 8920 try { 8921 const args = [ 8922 newValue, 8923 // pass undefined as the old value when it's changed for the first time 8924 oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue, 8925 boundCleanup 8926 ]; 8927 call ? call(cb, 3, args) : ( 8928 // @ts-expect-error 8929 cb(...args) 8930 ); 8931 oldValue = newValue; 8932 } finally { 8933 activeWatcher = currentWatcher; 8934 } 8935 } 8936 } else { 8937 effect.run(); 8938 } 8939 }; 8940 if (augmentJob) { 8941 augmentJob(job); 8942 } 8943 effect = new ReactiveEffect(getter); 8944 effect.scheduler = scheduler ? () => scheduler(job, false) : job; 8945 boundCleanup = (fn) => onWatcherCleanup(fn, false, effect); 8946 cleanup = effect.onStop = () => { 8947 const cleanups = cleanupMap.get(effect); 8948 if (cleanups) { 8949 if (call) { 8950 call(cleanups, 4); 8951 } else { 8952 for (const cleanup2 of cleanups) cleanup2(); 8953 } 8954 cleanupMap.delete(effect); 8955 } 8956 }; 8957 if (true) { 8958 effect.onTrack = options.onTrack; 8959 effect.onTrigger = options.onTrigger; 8960 } 8961 if (cb) { 8962 if (immediate) { 8963 job(true); 8964 } else { 8965 oldValue = effect.run(); 8966 } 8967 } else if (scheduler) { 8968 scheduler(job.bind(null, true), true); 8969 } else { 8970 effect.run(); 8971 } 8972 watchHandle.pause = effect.pause.bind(effect); 8973 watchHandle.resume = effect.resume.bind(effect); 8974 watchHandle.stop = watchHandle; 8975 return watchHandle; 8976} 8977function traverse(value, depth = Infinity, seen) { 8978 if (depth <= 0 || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(value) || value["__v_skip"]) { 8979 return value; 8980 } 8981 seen = seen || /* @__PURE__ */ new Set(); 8982 if (seen.has(value)) { 8983 return value; 8984 } 8985 seen.add(value); 8986 depth--; 8987 if (isRef(value)) { 8988 traverse(value.value, depth, seen); 8989 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(value)) { 8990 for (let i = 0; i < value.length; i++) { 8991 traverse(value[i], depth, seen); 8992 } 8993 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSet)(value) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(value)) { 8994 value.forEach((v) => { 8995 traverse(v, depth, seen); 8996 }); 8997 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isPlainObject)(value)) { 8998 for (const key in value) { 8999 traverse(value[key], depth, seen); 9000 } 9001 for (const key of Object.getOwnPropertySymbols(value)) { 9002 if (Object.prototype.propertyIsEnumerable.call(value, key)) { 9003 traverse(value[key], depth, seen); 9004 } 9005 } 9006 } 9007 return value; 9008} 9009 9010 9011 9012 9013/***/ }), 9014
vendor: 279,874 bytes, lines 9015-17540
9015/***/ "./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js": 9016/*!*************************************************************************!*\ 9017 !*** ./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js ***! 9018 \*************************************************************************/ 9019/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 9020 9021"use strict"; 9022__webpack_require__.r(__webpack_exports__); 9023/* harmony export */ __webpack_require__.d(__webpack_exports__, { 9024/* harmony export */ BaseTransition: () => (/* binding */ BaseTransition), 9025/* harmony export */ BaseTransitionPropsValidators: () => (/* binding */ BaseTransitionPropsValidators), 9026/* harmony export */ Comment: () => (/* binding */ Comment), 9027/* harmony export */ DeprecationTypes: () => (/* binding */ DeprecationTypes), 9028/* harmony export */ EffectScope: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.EffectScope), 9029/* harmony export */ ErrorCodes: () => (/* binding */ ErrorCodes), 9030/* harmony export */ ErrorTypeStrings: () => (/* binding */ ErrorTypeStrings), 9031/* harmony export */ Fragment: () => (/* binding */ Fragment), 9032/* harmony export */ KeepAlive: () => (/* binding */ KeepAlive), 9033/* harmony export */ ReactiveEffect: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect), 9034/* harmony export */ Static: () => (/* binding */ Static), 9035/* harmony export */ Suspense: () => (/* binding */ Suspense), 9036/* harmony export */ Teleport: () => (/* binding */ Teleport), 9037/* harmony export */ Text: () => (/* binding */ Text), 9038/* harmony export */ TrackOpTypes: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.TrackOpTypes), 9039/* harmony export */ TriggerOpTypes: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.TriggerOpTypes), 9040/* harmony export */ assertNumber: () => (/* binding */ assertNumber), 9041/* harmony export */ callWithAsyncErrorHandling: () => (/* binding */ callWithAsyncErrorHandling), 9042/* harmony export */ callWithErrorHandling: () => (/* binding */ callWithErrorHandling), 9043/* harmony export */ camelize: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize), 9044/* harmony export */ capitalize: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize), 9045/* harmony export */ cloneVNode: () => (/* binding */ cloneVNode), 9046/* harmony export */ compatUtils: () => (/* binding */ compatUtils), 9047/* harmony export */ computed: () => (/* binding */ computed), 9048/* harmony export */ createBlock: () => (/* binding */ createBlock), 9049/* harmony export */ createCommentVNode: () => (/* binding */ createCommentVNode), 9050/* harmony export */ createElementBlock: () => (/* binding */ createElementBlock), 9051/* harmony export */ createElementVNode: () => (/* binding */ createBaseVNode), 9052/* harmony export */ createHydrationRenderer: () => (/* binding */ createHydrationRenderer), 9053/* harmony export */ createPropsRestProxy: () => (/* binding */ createPropsRestProxy), 9054/* harmony export */ createRenderer: () => (/* binding */ createRenderer), 9055/* harmony export */ createSlots: () => (/* binding */ createSlots), 9056/* harmony export */ createStaticVNode: () => (/* binding */ createStaticVNode), 9057/* harmony export */ createTextVNode: () => (/* binding */ createTextVNode), 9058/* harmony export */ createVNode: () => (/* binding */ createVNode), 9059/* harmony export */ customRef: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.customRef), 9060/* harmony export */ defineAsyncComponent: () => (/* binding */ defineAsyncComponent), 9061/* harmony export */ defineComponent: () => (/* binding */ defineComponent), 9062/* harmony export */ defineEmits: () => (/* binding */ defineEmits), 9063/* harmony export */ defineExpose: () => (/* binding */ defineExpose), 9064/* harmony export */ defineModel: () => (/* binding */ defineModel), 9065/* harmony export */ defineOptions: () => (/* binding */ defineOptions), 9066/* harmony export */ defineProps: () => (/* binding */ defineProps), 9067/* harmony export */ defineSlots: () => (/* binding */ defineSlots), 9068/* harmony export */ devtools: () => (/* binding */ devtools), 9069/* harmony export */ effect: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.effect), 9070/* harmony export */ effectScope: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.effectScope), 9071/* harmony export */ getCurrentInstance: () => (/* binding */ getCurrentInstance), 9072/* harmony export */ getCurrentScope: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope), 9073/* harmony export */ getCurrentWatcher: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.getCurrentWatcher), 9074/* harmony export */ getTransitionRawChildren: () => (/* binding */ getTransitionRawChildren), 9075/* harmony export */ guardReactiveProps: () => (/* binding */ guardReactiveProps), 9076/* harmony export */ h: () => (/* binding */ h), 9077/* harmony export */ handleError: () => (/* binding */ handleError), 9078/* harmony export */ hasInjectionContext: () => (/* binding */ hasInjectionContext), 9079/* harmony export */ hydrateOnIdle: () => (/* binding */ hydrateOnIdle), 9080/* harmony export */ hydrateOnInteraction: () => (/* binding */ hydrateOnInteraction), 9081/* harmony export */ hydrateOnMediaQuery: () => (/* binding */ hydrateOnMediaQuery), 9082/* harmony export */ hydrateOnVisible: () => (/* binding */ hydrateOnVisible), 9083/* harmony export */ initCustomFormatter: () => (/* binding */ initCustomFormatter), 9084/* harmony export */ inject: () => (/* binding */ inject), 9085/* harmony export */ isMemoSame: () => (/* binding */ isMemoSame), 9086/* harmony export */ isProxy: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy), 9087/* harmony export */ isReactive: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive), 9088/* harmony export */ isReadonly: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReadonly), 9089/* harmony export */ isRef: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef), 9090/* harmony export */ isRuntimeOnly: () => (/* binding */ isRuntimeOnly), 9091/* harmony export */ isShallow: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow), 9092/* harmony export */ isVNode: () => (/* binding */ isVNode), 9093/* harmony export */ markRaw: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.markRaw), 9094/* harmony export */ mergeDefaults: () => (/* binding */ mergeDefaults), 9095/* harmony export */ mergeModels: () => (/* binding */ mergeModels), 9096/* harmony export */ mergeProps: () => (/* binding */ mergeProps), 9097/* harmony export */ nextTick: () => (/* binding */ nextTick), 9098/* harmony export */ normalizeClass: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass), 9099/* harmony export */ normalizeProps: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeProps), 9100/* harmony export */ normalizeStyle: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle), 9101/* harmony export */ onActivated: () => (/* binding */ onActivated), 9102/* harmony export */ onBeforeMount: () => (/* binding */ onBeforeMount), 9103/* harmony export */ onBeforeUnmount: () => (/* binding */ onBeforeUnmount), 9104/* harmony export */ onBeforeUpdate: () => (/* binding */ onBeforeUpdate), 9105/* harmony export */ onDeactivated: () => (/* binding */ onDeactivated), 9106/* harmony export */ onErrorCaptured: () => (/* binding */ onErrorCaptured), 9107/* harmony export */ onMounted: () => (/* binding */ onMounted), 9108/* harmony export */ onRenderTracked: () => (/* binding */ onRenderTracked), 9109/* harmony export */ onRenderTriggered: () => (/* binding */ onRenderTriggered), 9110/* harmony export */ onScopeDispose: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose), 9111/* harmony export */ onServerPrefetch: () => (/* binding */ onServerPrefetch), 9112/* harmony export */ onUnmounted: () => (/* binding */ onUnmounted), 9113/* harmony export */ onUpdated: () => (/* binding */ onUpdated), 9114/* harmony export */ onWatcherCleanup: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.onWatcherCleanup), 9115/* harmony export */ openBlock: () => (/* binding */ openBlock), 9116/* harmony export */ popScopeId: () => (/* binding */ popScopeId), 9117/* harmony export */ provide: () => (/* binding */ provide), 9118/* harmony export */ proxyRefs: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.proxyRefs), 9119/* harmony export */ pushScopeId: () => (/* binding */ pushScopeId), 9120/* harmony export */ queuePostFlushCb: () => (/* binding */ queuePostFlushCb), 9121/* harmony export */ reactive: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.reactive), 9122/* harmony export */ readonly: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.readonly), 9123/* harmony export */ ref: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref), 9124/* harmony export */ registerRuntimeCompiler: () => (/* binding */ registerRuntimeCompiler), 9125/* harmony export */ renderList: () => (/* binding */ renderList), 9126/* harmony export */ renderSlot: () => (/* binding */ renderSlot), 9127/* harmony export */ resolveComponent: () => (/* binding */ resolveComponent), 9128/* harmony export */ resolveDirective: () => (/* binding */ resolveDirective), 9129/* harmony export */ resolveDynamicComponent: () => (/* binding */ resolveDynamicComponent), 9130/* harmony export */ resolveFilter: () => (/* binding */ resolveFilter), 9131/* harmony export */ resolveTransitionHooks: () => (/* binding */ resolveTransitionHooks), 9132/* harmony export */ setBlockTracking: () => (/* binding */ setBlockTracking), 9133/* harmony export */ setDevtoolsHook: () => (/* binding */ setDevtoolsHook), 9134/* harmony export */ setTransitionHooks: () => (/* binding */ setTransitionHooks), 9135/* harmony export */ shallowReactive: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReactive), 9136/* harmony export */ shallowReadonly: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly), 9137/* harmony export */ shallowRef: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowRef), 9138/* harmony export */ ssrContextKey: () => (/* binding */ ssrContextKey), 9139/* harmony export */ ssrUtils: () => (/* binding */ ssrUtils), 9140/* harmony export */ stop: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.stop), 9141/* harmony export */ toDisplayString: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.toDisplayString), 9142/* harmony export */ toHandlerKey: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey), 9143/* harmony export */ toHandlers: () => (/* binding */ toHandlers), 9144/* harmony export */ toRaw: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw), 9145/* harmony export */ toRef: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRef), 9146/* harmony export */ toRefs: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRefs), 9147/* harmony export */ toValue: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toValue), 9148/* harmony export */ transformVNodeArgs: () => (/* binding */ transformVNodeArgs), 9149/* harmony export */ triggerRef: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.triggerRef), 9150/* harmony export */ unref: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.unref), 9151/* harmony export */ useAttrs: () => (/* binding */ useAttrs), 9152/* harmony export */ useId: () => (/* binding */ useId), 9153/* harmony export */ useModel: () => (/* binding */ useModel), 9154/* harmony export */ useSSRContext: () => (/* binding */ useSSRContext), 9155/* harmony export */ useSlots: () => (/* binding */ useSlots), 9156/* harmony export */ useTemplateRef: () => (/* binding */ useTemplateRef), 9157/* harmony export */ useTransitionState: () => (/* binding */ useTransitionState), 9158/* harmony export */ version: () => (/* binding */ version), 9159/* harmony export */ warn: () => (/* binding */ warn), 9160/* harmony export */ watch: () => (/* binding */ watch), 9161/* harmony export */ watchEffect: () => (/* binding */ watchEffect), 9162/* harmony export */ watchPostEffect: () => (/* binding */ watchPostEffect), 9163/* harmony export */ watchSyncEffect: () => (/* binding */ watchSyncEffect), 9164/* harmony export */ withAsyncContext: () => (/* binding */ withAsyncContext), 9165/* harmony export */ withCtx: () => (/* binding */ withCtx), 9166/* harmony export */ withDefaults: () => (/* binding */ withDefaults), 9167/* harmony export */ withDirectives: () => (/* binding */ withDirectives), 9168/* harmony export */ withMemo: () => (/* binding */ withMemo), 9169/* harmony export */ withScopeId: () => (/* binding */ withScopeId) 9170/* harmony export */ }); 9171/* harmony import */ var _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/reactivity */ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js"); 9172/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 9173/** 9174* @vue/runtime-core v3.5.13 9175* (c) 2018-present Yuxi (Evan) You and Vue contributors 9176* @license MIT 9177**/ 9178 9179 9180 9181 9182 9183const stack = []; 9184function pushWarningContext(vnode) { 9185 stack.push(vnode); 9186} 9187function popWarningContext() { 9188 stack.pop(); 9189} 9190let isWarning = false; 9191function warn$1(msg, ...args) { 9192 if (isWarning) return; 9193 isWarning = true; 9194 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 9195 const instance = stack.length ? stack[stack.length - 1].component : null; 9196 const appWarnHandler = instance && instance.appContext.config.warnHandler; 9197 const trace = getComponentTrace(); 9198 if (appWarnHandler) { 9199 callWithErrorHandling( 9200 appWarnHandler, 9201 instance, 9202 11, 9203 [ 9204 // eslint-disable-next-line no-restricted-syntax 9205 msg + args.map((a) => { 9206 var _a, _b; 9207 return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a); 9208 }).join(""), 9209 instance && instance.proxy, 9210 trace.map( 9211 ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>` 9212 ).join("\n"), 9213 trace 9214 ] 9215 ); 9216 } else { 9217 const warnArgs = [`[Vue warn]: ${msg}`, ...args]; 9218 if (trace.length && // avoid spamming console during tests 9219 true) { 9220 warnArgs.push(` 9221`, ...formatTrace(trace)); 9222 } 9223 console.warn(...warnArgs); 9224 } 9225 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 9226 isWarning = false; 9227} 9228function getComponentTrace() { 9229 let currentVNode = stack[stack.length - 1]; 9230 if (!currentVNode) { 9231 return []; 9232 } 9233 const normalizedStack = []; 9234 while (currentVNode) { 9235 const last = normalizedStack[0]; 9236 if (last && last.vnode === currentVNode) { 9237 last.recurseCount++; 9238 } else { 9239 normalizedStack.push({ 9240 vnode: currentVNode, 9241 recurseCount: 0 9242 }); 9243 } 9244 const parentInstance = currentVNode.component && currentVNode.component.parent; 9245 currentVNode = parentInstance && parentInstance.vnode; 9246 } 9247 return normalizedStack; 9248} 9249function formatTrace(trace) { 9250 const logs = []; 9251 trace.forEach((entry, i) => { 9252 logs.push(...i === 0 ? [] : [` 9253`], ...formatTraceEntry(entry)); 9254 }); 9255 return logs; 9256} 9257function formatTraceEntry({ vnode, recurseCount }) { 9258 const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; 9259 const isRoot = vnode.component ? vnode.component.parent == null : false; 9260 const open = ` at <${formatComponentName( 9261 vnode.component, 9262 vnode.type, 9263 isRoot 9264 )}`; 9265 const close = `>` + postfix; 9266 return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close]; 9267} 9268function formatProps(props) { 9269 const res = []; 9270 const keys = Object.keys(props); 9271 keys.slice(0, 3).forEach((key) => { 9272 res.push(...formatProp(key, props[key])); 9273 }); 9274 if (keys.length > 3) { 9275 res.push(` ...`); 9276 } 9277 return res; 9278} 9279function formatProp(key, value, raw) { 9280 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(value)) { 9281 value = JSON.stringify(value); 9282 return raw ? value : [`${key}=${value}`]; 9283 } else if (typeof value === "number" || typeof value === "boolean" || value == null) { 9284 return raw ? value : [`${key}=${value}`]; 9285 } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(value)) { 9286 value = formatProp(key, (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(value.value), true); 9287 return raw ? value : [`${key}=Ref<`, value, `>`]; 9288 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) { 9289 return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; 9290 } else { 9291 value = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(value); 9292 return raw ? value : [`${key}=`, value]; 9293 } 9294} 9295function assertNumber(val, type) { 9296 if (false) {} 9297 if (val === void 0) { 9298 return; 9299 } else if (typeof val !== "number") { 9300 warn$1(`${type} is not a valid number - got ${JSON.stringify(val)}.`); 9301 } else if (isNaN(val)) { 9302 warn$1(`${type} is NaN - the duration expression might be incorrect.`); 9303 } 9304} 9305 9306const ErrorCodes = { 9307 "SETUP_FUNCTION": 0, 9308 "0": "SETUP_FUNCTION", 9309 "RENDER_FUNCTION": 1, 9310 "1": "RENDER_FUNCTION", 9311 "NATIVE_EVENT_HANDLER": 5, 9312 "5": "NATIVE_EVENT_HANDLER", 9313 "COMPONENT_EVENT_HANDLER": 6, 9314 "6": "COMPONENT_EVENT_HANDLER", 9315 "VNODE_HOOK": 7, 9316 "7": "VNODE_HOOK", 9317 "DIRECTIVE_HOOK": 8, 9318 "8": "DIRECTIVE_HOOK", 9319 "TRANSITION_HOOK": 9, 9320 "9": "TRANSITION_HOOK", 9321 "APP_ERROR_HANDLER": 10, 9322 "10": "APP_ERROR_HANDLER", 9323 "APP_WARN_HANDLER": 11, 9324 "11": "APP_WARN_HANDLER", 9325 "FUNCTION_REF": 12, 9326 "12": "FUNCTION_REF", 9327 "ASYNC_COMPONENT_LOADER": 13, 9328 "13": "ASYNC_COMPONENT_LOADER", 9329 "SCHEDULER": 14, 9330 "14": "SCHEDULER", 9331 "COMPONENT_UPDATE": 15, 9332 "15": "COMPONENT_UPDATE", 9333 "APP_UNMOUNT_CLEANUP": 16, 9334 "16": "APP_UNMOUNT_CLEANUP" 9335}; 9336const ErrorTypeStrings$1 = { 9337 ["sp"]: "serverPrefetch hook", 9338 ["bc"]: "beforeCreate hook", 9339 ["c"]: "created hook", 9340 ["bm"]: "beforeMount hook", 9341 ["m"]: "mounted hook", 9342 ["bu"]: "beforeUpdate hook", 9343 ["u"]: "updated", 9344 ["bum"]: "beforeUnmount hook", 9345 ["um"]: "unmounted hook", 9346 ["a"]: "activated hook", 9347 ["da"]: "deactivated hook", 9348 ["ec"]: "errorCaptured hook", 9349 ["rtc"]: "renderTracked hook", 9350 ["rtg"]: "renderTriggered hook", 9351 [0]: "setup function", 9352 [1]: "render function", 9353 [2]: "watcher getter", 9354 [3]: "watcher callback", 9355 [4]: "watcher cleanup function", 9356 [5]: "native event handler", 9357 [6]: "component event handler", 9358 [7]: "vnode hook", 9359 [8]: "directive hook", 9360 [9]: "transition hook", 9361 [10]: "app errorHandler", 9362 [11]: "app warnHandler", 9363 [12]: "ref function", 9364 [13]: "async component loader", 9365 [14]: "scheduler flush", 9366 [15]: "component update", 9367 [16]: "app unmount cleanup function" 9368}; 9369function callWithErrorHandling(fn, instance, type, args) { 9370 try { 9371 return args ? fn(...args) : fn(); 9372 } catch (err) { 9373 handleError(err, instance, type); 9374 } 9375} 9376function callWithAsyncErrorHandling(fn, instance, type, args) { 9377 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(fn)) { 9378 const res = callWithErrorHandling(fn, instance, type, args); 9379 if (res && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(res)) { 9380 res.catch((err) => { 9381 handleError(err, instance, type); 9382 }); 9383 } 9384 return res; 9385 } 9386 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(fn)) { 9387 const values = []; 9388 for (let i = 0; i < fn.length; i++) { 9389 values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); 9390 } 9391 return values; 9392 } else if (true) { 9393 warn$1( 9394 `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}` 9395 ); 9396 } 9397} 9398function handleError(err, instance, type, throwInDev = true) { 9399 const contextVNode = instance ? instance.vnode : null; 9400 const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 9401 if (instance) { 9402 let cur = instance.parent; 9403 const exposedInstance = instance.proxy; 9404 const errorInfo = true ? ErrorTypeStrings$1[type] : 0; 9405 while (cur) { 9406 const errorCapturedHooks = cur.ec; 9407 if (errorCapturedHooks) { 9408 for (let i = 0; i < errorCapturedHooks.length; i++) { 9409 if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { 9410 return; 9411 } 9412 } 9413 } 9414 cur = cur.parent; 9415 } 9416 if (errorHandler) { 9417 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 9418 callWithErrorHandling(errorHandler, null, 10, [ 9419 err, 9420 exposedInstance, 9421 errorInfo 9422 ]); 9423 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 9424 return; 9425 } 9426 } 9427 logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction); 9428} 9429function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) { 9430 if (true) { 9431 const info = ErrorTypeStrings$1[type]; 9432 if (contextVNode) { 9433 pushWarningContext(contextVNode); 9434 } 9435 warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`); 9436 if (contextVNode) { 9437 popWarningContext(); 9438 } 9439 if (throwInDev) { 9440 throw err; 9441 } else { 9442 console.error(err); 9443 } 9444 } else {} 9445} 9446 9447const queue = []; 9448let flushIndex = -1; 9449const pendingPostFlushCbs = []; 9450let activePostFlushCbs = null; 9451let postFlushIndex = 0; 9452const resolvedPromise = /* @__PURE__ */ Promise.resolve(); 9453let currentFlushPromise = null; 9454const RECURSION_LIMIT = 100; 9455function nextTick(fn) { 9456 const p = currentFlushPromise || resolvedPromise; 9457 return fn ? p.then(this ? fn.bind(this) : fn) : p; 9458} 9459function findInsertionIndex(id) { 9460 let start = flushIndex + 1; 9461 let end = queue.length; 9462 while (start < end) { 9463 const middle = start + end >>> 1; 9464 const middleJob = queue[middle]; 9465 const middleJobId = getId(middleJob); 9466 if (middleJobId < id || middleJobId === id && middleJob.flags & 2) { 9467 start = middle + 1; 9468 } else { 9469 end = middle; 9470 } 9471 } 9472 return start; 9473} 9474function queueJob(job) { 9475 if (!(job.flags & 1)) { 9476 const jobId = getId(job); 9477 const lastJob = queue[queue.length - 1]; 9478 if (!lastJob || // fast path when the job id is larger than the tail 9479 !(job.flags & 2) && jobId >= getId(lastJob)) { 9480 queue.push(job); 9481 } else { 9482 queue.splice(findInsertionIndex(jobId), 0, job); 9483 } 9484 job.flags |= 1; 9485 queueFlush(); 9486 } 9487} 9488function queueFlush() { 9489 if (!currentFlushPromise) { 9490 currentFlushPromise = resolvedPromise.then(flushJobs); 9491 } 9492} 9493function queuePostFlushCb(cb) { 9494 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(cb)) { 9495 if (activePostFlushCbs && cb.id === -1) { 9496 activePostFlushCbs.splice(postFlushIndex + 1, 0, cb); 9497 } else if (!(cb.flags & 1)) { 9498 pendingPostFlushCbs.push(cb); 9499 cb.flags |= 1; 9500 } 9501 } else { 9502 pendingPostFlushCbs.push(...cb); 9503 } 9504 queueFlush(); 9505} 9506function flushPreFlushCbs(instance, seen, i = flushIndex + 1) { 9507 if (true) { 9508 seen = seen || /* @__PURE__ */ new Map(); 9509 } 9510 for (; i < queue.length; i++) { 9511 const cb = queue[i]; 9512 if (cb && cb.flags & 2) { 9513 if (instance && cb.id !== instance.uid) { 9514 continue; 9515 } 9516 if ( true && checkRecursiveUpdates(seen, cb)) { 9517 continue; 9518 } 9519 queue.splice(i, 1); 9520 i--; 9521 if (cb.flags & 4) { 9522 cb.flags &= ~1; 9523 } 9524 cb(); 9525 if (!(cb.flags & 4)) { 9526 cb.flags &= ~1; 9527 } 9528 } 9529 } 9530} 9531function flushPostFlushCbs(seen) { 9532 if (pendingPostFlushCbs.length) { 9533 const deduped = [...new Set(pendingPostFlushCbs)].sort( 9534 (a, b) => getId(a) - getId(b) 9535 ); 9536 pendingPostFlushCbs.length = 0; 9537 if (activePostFlushCbs) { 9538 activePostFlushCbs.push(...deduped); 9539 return; 9540 } 9541 activePostFlushCbs = deduped; 9542 if (true) { 9543 seen = seen || /* @__PURE__ */ new Map(); 9544 } 9545 for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { 9546 const cb = activePostFlushCbs[postFlushIndex]; 9547 if ( true && checkRecursiveUpdates(seen, cb)) { 9548 continue; 9549 } 9550 if (cb.flags & 4) { 9551 cb.flags &= ~1; 9552 } 9553 if (!(cb.flags & 8)) cb(); 9554 cb.flags &= ~1; 9555 } 9556 activePostFlushCbs = null; 9557 postFlushIndex = 0; 9558 } 9559} 9560const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id; 9561function flushJobs(seen) { 9562 if (true) { 9563 seen = seen || /* @__PURE__ */ new Map(); 9564 } 9565 const check = true ? (job) => checkRecursiveUpdates(seen, job) : 0; 9566 try { 9567 for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { 9568 const job = queue[flushIndex]; 9569 if (job && !(job.flags & 8)) { 9570 if ( true && check(job)) { 9571 continue; 9572 } 9573 if (job.flags & 4) { 9574 job.flags &= ~1; 9575 } 9576 callWithErrorHandling( 9577 job, 9578 job.i, 9579 job.i ? 15 : 14 9580 ); 9581 if (!(job.flags & 4)) { 9582 job.flags &= ~1; 9583 } 9584 } 9585 } 9586 } finally { 9587 for (; flushIndex < queue.length; flushIndex++) { 9588 const job = queue[flushIndex]; 9589 if (job) { 9590 job.flags &= ~1; 9591 } 9592 } 9593 flushIndex = -1; 9594 queue.length = 0; 9595 flushPostFlushCbs(seen); 9596 currentFlushPromise = null; 9597 if (queue.length || pendingPostFlushCbs.length) { 9598 flushJobs(seen); 9599 } 9600 } 9601} 9602function checkRecursiveUpdates(seen, fn) { 9603 const count = seen.get(fn) || 0; 9604 if (count > RECURSION_LIMIT) { 9605 const instance = fn.i; 9606 const componentName = instance && getComponentName(instance.type); 9607 handleError( 9608 `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`, 9609 null, 9610 10 9611 ); 9612 return true; 9613 } 9614 seen.set(fn, count + 1); 9615 return false; 9616} 9617 9618let isHmrUpdating = false; 9619const hmrDirtyComponents = /* @__PURE__ */ new Map(); 9620if (true) { 9621 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)().__VUE_HMR_RUNTIME__ = { 9622 createRecord: tryWrap(createRecord), 9623 rerender: tryWrap(rerender), 9624 reload: tryWrap(reload) 9625 }; 9626} 9627const map = /* @__PURE__ */ new Map(); 9628function registerHMR(instance) { 9629 const id = instance.type.__hmrId; 9630 let record = map.get(id); 9631 if (!record) { 9632 createRecord(id, instance.type); 9633 record = map.get(id); 9634 } 9635 record.instances.add(instance); 9636} 9637function unregisterHMR(instance) { 9638 map.get(instance.type.__hmrId).instances.delete(instance); 9639} 9640function createRecord(id, initialDef) { 9641 if (map.has(id)) { 9642 return false; 9643 } 9644 map.set(id, { 9645 initialDef: normalizeClassComponent(initialDef), 9646 instances: /* @__PURE__ */ new Set() 9647 }); 9648 return true; 9649} 9650function normalizeClassComponent(component) { 9651 return isClassComponent(component) ? component.__vccOpts : component; 9652} 9653function rerender(id, newRender) { 9654 const record = map.get(id); 9655 if (!record) { 9656 return; 9657 } 9658 record.initialDef.render = newRender; 9659 [...record.instances].forEach((instance) => { 9660 if (newRender) { 9661 instance.render = newRender; 9662 normalizeClassComponent(instance.type).render = newRender; 9663 } 9664 instance.renderCache = []; 9665 isHmrUpdating = true; 9666 instance.update(); 9667 isHmrUpdating = false; 9668 }); 9669} 9670function reload(id, newComp) { 9671 const record = map.get(id); 9672 if (!record) return; 9673 newComp = normalizeClassComponent(newComp); 9674 updateComponentDef(record.initialDef, newComp); 9675 const instances = [...record.instances]; 9676 for (let i = 0; i < instances.length; i++) { 9677 const instance = instances[i]; 9678 const oldComp = normalizeClassComponent(instance.type); 9679 let dirtyInstances = hmrDirtyComponents.get(oldComp); 9680 if (!dirtyInstances) { 9681 if (oldComp !== record.initialDef) { 9682 updateComponentDef(oldComp, newComp); 9683 } 9684 hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set()); 9685 } 9686 dirtyInstances.add(instance); 9687 instance.appContext.propsCache.delete(instance.type); 9688 instance.appContext.emitsCache.delete(instance.type); 9689 instance.appContext.optionsCache.delete(instance.type); 9690 if (instance.ceReload) { 9691 dirtyInstances.add(instance); 9692 instance.ceReload(newComp.styles); 9693 dirtyInstances.delete(instance); 9694 } else if (instance.parent) { 9695 queueJob(() => { 9696 isHmrUpdating = true; 9697 instance.parent.update(); 9698 isHmrUpdating = false; 9699 dirtyInstances.delete(instance); 9700 }); 9701 } else if (instance.appContext.reload) { 9702 instance.appContext.reload(); 9703 } else if (typeof window !== "undefined") { 9704 window.location.reload(); 9705 } else { 9706 console.warn( 9707 "[HMR] Root or manually mounted instance modified. Full reload required." 9708 ); 9709 } 9710 if (instance.root.ce && instance !== instance.root) { 9711 instance.root.ce._removeChildStyle(oldComp); 9712 } 9713 } 9714 queuePostFlushCb(() => { 9715 hmrDirtyComponents.clear(); 9716 }); 9717} 9718function updateComponentDef(oldComp, newComp) { 9719 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(oldComp, newComp); 9720 for (const key in oldComp) { 9721 if (key !== "__file" && !(key in newComp)) { 9722 delete oldComp[key]; 9723 } 9724 } 9725} 9726function tryWrap(fn) { 9727 return (id, arg) => { 9728 try { 9729 return fn(id, arg); 9730 } catch (e) { 9731 console.error(e); 9732 console.warn( 9733 `[HMR] Something went wrong during Vue component hot-reload. Full reload required.` 9734 ); 9735 } 9736 }; 9737} 9738 9739let devtools$1; 9740let buffer = []; 9741let devtoolsNotInstalled = false; 9742function emit$1(event, ...args) { 9743 if (devtools$1) { 9744 devtools$1.emit(event, ...args); 9745 } else if (!devtoolsNotInstalled) { 9746 buffer.push({ event, args }); 9747 } 9748} 9749function setDevtoolsHook$1(hook, target) { 9750 var _a, _b; 9751 devtools$1 = hook; 9752 if (devtools$1) { 9753 devtools$1.enabled = true; 9754 buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args)); 9755 buffer = []; 9756 } else if ( 9757 // handle late devtools injection - only do this if we are in an actual 9758 // browser environment to avoid the timer handle stalling test runner exit 9759 // (#4815) 9760 typeof window !== "undefined" && // some envs mock window but not fully 9761 window.HTMLElement && // also exclude jsdom 9762 // eslint-disable-next-line no-restricted-syntax 9763 !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom")) 9764 ) { 9765 const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || []; 9766 replay.push((newHook) => { 9767 setDevtoolsHook$1(newHook, target); 9768 }); 9769 setTimeout(() => { 9770 if (!devtools$1) { 9771 target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null; 9772 devtoolsNotInstalled = true; 9773 buffer = []; 9774 } 9775 }, 3e3); 9776 } else { 9777 devtoolsNotInstalled = true; 9778 buffer = []; 9779 } 9780} 9781function devtoolsInitApp(app, version) { 9782 emit$1("app:init" /* APP_INIT */, app, version, { 9783 Fragment, 9784 Text, 9785 Comment, 9786 Static 9787 }); 9788} 9789function devtoolsUnmountApp(app) { 9790 emit$1("app:unmount" /* APP_UNMOUNT */, app); 9791} 9792const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook("component:added" /* COMPONENT_ADDED */); 9793const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */); 9794const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook( 9795 "component:removed" /* COMPONENT_REMOVED */ 9796); 9797const devtoolsComponentRemoved = (component) => { 9798 if (devtools$1 && typeof devtools$1.cleanupBuffer === "function" && // remove the component if it wasn't buffered 9799 !devtools$1.cleanupBuffer(component)) { 9800 _devtoolsComponentRemoved(component); 9801 } 9802}; 9803/*! #__NO_SIDE_EFFECTS__ */ 9804// @__NO_SIDE_EFFECTS__ 9805function createDevtoolsComponentHook(hook) { 9806 return (component) => { 9807 emit$1( 9808 hook, 9809 component.appContext.app, 9810 component.uid, 9811 component.parent ? component.parent.uid : void 0, 9812 component 9813 ); 9814 }; 9815} 9816const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook("perf:start" /* PERFORMANCE_START */); 9817const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook("perf:end" /* PERFORMANCE_END */); 9818function createDevtoolsPerformanceHook(hook) { 9819 return (component, type, time) => { 9820 emit$1(hook, component.appContext.app, component.uid, component, type, time); 9821 }; 9822} 9823function devtoolsComponentEmit(component, event, params) { 9824 emit$1( 9825 "component:emit" /* COMPONENT_EMIT */, 9826 component.appContext.app, 9827 component, 9828 event, 9829 params 9830 ); 9831} 9832 9833let currentRenderingInstance = null; 9834let currentScopeId = null; 9835function setCurrentRenderingInstance(instance) { 9836 const prev = currentRenderingInstance; 9837 currentRenderingInstance = instance; 9838 currentScopeId = instance && instance.type.__scopeId || null; 9839 return prev; 9840} 9841function pushScopeId(id) { 9842 currentScopeId = id; 9843} 9844function popScopeId() { 9845 currentScopeId = null; 9846} 9847const withScopeId = (_id) => withCtx; 9848function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) { 9849 if (!ctx) return fn; 9850 if (fn._n) { 9851 return fn; 9852 } 9853 const renderFnWithContext = (...args) => { 9854 if (renderFnWithContext._d) { 9855 setBlockTracking(-1); 9856 } 9857 const prevInstance = setCurrentRenderingInstance(ctx); 9858 let res; 9859 try { 9860 res = fn(...args); 9861 } finally { 9862 setCurrentRenderingInstance(prevInstance); 9863 if (renderFnWithContext._d) { 9864 setBlockTracking(1); 9865 } 9866 } 9867 if (true) { 9868 devtoolsComponentUpdated(ctx); 9869 } 9870 return res; 9871 }; 9872 renderFnWithContext._n = true; 9873 renderFnWithContext._c = true; 9874 renderFnWithContext._d = true; 9875 return renderFnWithContext; 9876} 9877 9878function validateDirectiveName(name) { 9879 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isBuiltInDirective)(name)) { 9880 warn$1("Do not use built-in directive ids as custom directive id: " + name); 9881 } 9882} 9883function withDirectives(vnode, directives) { 9884 if (currentRenderingInstance === null) { 9885 true && warn$1(`withDirectives can only be used inside render functions.`); 9886 return vnode; 9887 } 9888 const instance = getComponentPublicInstance(currentRenderingInstance); 9889 const bindings = vnode.dirs || (vnode.dirs = []); 9890 for (let i = 0; i < directives.length; i++) { 9891 let [dir, value, arg, modifiers = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ] = directives[i]; 9892 if (dir) { 9893 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(dir)) { 9894 dir = { 9895 mounted: dir, 9896 updated: dir 9897 }; 9898 } 9899 if (dir.deep) { 9900 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.traverse)(value); 9901 } 9902 bindings.push({ 9903 dir, 9904 instance, 9905 value, 9906 oldValue: void 0, 9907 arg, 9908 modifiers 9909 }); 9910 } 9911 } 9912 return vnode; 9913} 9914function invokeDirectiveHook(vnode, prevVNode, instance, name) { 9915 const bindings = vnode.dirs; 9916 const oldBindings = prevVNode && prevVNode.dirs; 9917 for (let i = 0; i < bindings.length; i++) { 9918 const binding = bindings[i]; 9919 if (oldBindings) { 9920 binding.oldValue = oldBindings[i].value; 9921 } 9922 let hook = binding.dir[name]; 9923 if (hook) { 9924 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 9925 callWithAsyncErrorHandling(hook, instance, 8, [ 9926 vnode.el, 9927 binding, 9928 vnode, 9929 prevVNode 9930 ]); 9931 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 9932 } 9933 } 9934} 9935 9936const TeleportEndKey = Symbol("_vte"); 9937const isTeleport = (type) => type.__isTeleport; 9938const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === ""); 9939const isTeleportDeferred = (props) => props && (props.defer || props.defer === ""); 9940const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement; 9941const isTargetMathML = (target) => typeof MathMLElement === "function" && target instanceof MathMLElement; 9942const resolveTarget = (props, select) => { 9943 const targetSelector = props && props.to; 9944 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(targetSelector)) { 9945 if (!select) { 9946 true && warn$1( 9947 `Current renderer does not support string target for Teleports. (missing querySelector renderer option)` 9948 ); 9949 return null; 9950 } else { 9951 const target = select(targetSelector); 9952 if ( true && !target && !isTeleportDisabled(props)) { 9953 warn$1( 9954 `Failed to locate Teleport target with selector "${targetSelector}". Note the target element must exist before the component is mounted - i.e. the target cannot be rendered by the component itself, and ideally should be outside of the entire Vue component tree.` 9955 ); 9956 } 9957 return target; 9958 } 9959 } else { 9960 if ( true && !targetSelector && !isTeleportDisabled(props)) { 9961 warn$1(`Invalid Teleport target: ${targetSelector}`); 9962 } 9963 return targetSelector; 9964 } 9965}; 9966const TeleportImpl = { 9967 name: "Teleport", 9968 __isTeleport: true, 9969 process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) { 9970 const { 9971 mc: mountChildren, 9972 pc: patchChildren, 9973 pbc: patchBlockChildren, 9974 o: { insert, querySelector, createText, createComment } 9975 } = internals; 9976 const disabled = isTeleportDisabled(n2.props); 9977 let { shapeFlag, children, dynamicChildren } = n2; 9978 if ( true && isHmrUpdating) { 9979 optimized = false; 9980 dynamicChildren = null; 9981 } 9982 if (n1 == null) { 9983 const placeholder = n2.el = true ? createComment("teleport start") : 0; 9984 const mainAnchor = n2.anchor = true ? createComment("teleport end") : 0; 9985 insert(placeholder, container, anchor); 9986 insert(mainAnchor, container, anchor); 9987 const mount = (container2, anchor2) => { 9988 if (shapeFlag & 16) { 9989 if (parentComponent && parentComponent.isCE) { 9990 parentComponent.ce._teleportTarget = container2; 9991 } 9992 mountChildren( 9993 children, 9994 container2, 9995 anchor2, 9996 parentComponent, 9997 parentSuspense, 9998 namespace, 9999 slotScopeIds, 10000 optimized 10001 ); 10002 } 10003 }; 10004 const mountToTarget = () => { 10005 const target = n2.target = resolveTarget(n2.props, querySelector); 10006 const targetAnchor = prepareAnchor(target, n2, createText, insert); 10007 if (target) { 10008 if (namespace !== "svg" && isTargetSVG(target)) { 10009 namespace = "svg"; 10010 } else if (namespace !== "mathml" && isTargetMathML(target)) { 10011 namespace = "mathml"; 10012 } 10013 if (!disabled) { 10014 mount(target, targetAnchor); 10015 updateCssVars(n2, false); 10016 } 10017 } else if ( true && !disabled) { 10018 warn$1( 10019 "Invalid Teleport target on mount:", 10020 target, 10021 `(${typeof target})` 10022 ); 10023 } 10024 }; 10025 if (disabled) { 10026 mount(container, mainAnchor); 10027 updateCssVars(n2, true); 10028 } 10029 if (isTeleportDeferred(n2.props)) { 10030 queuePostRenderEffect(() => { 10031 mountToTarget(); 10032 n2.el.__isMounted = true; 10033 }, parentSuspense); 10034 } else { 10035 mountToTarget(); 10036 } 10037 } else { 10038 if (isTeleportDeferred(n2.props) && !n1.el.__isMounted) { 10039 queuePostRenderEffect(() => { 10040 TeleportImpl.process( 10041 n1, 10042 n2, 10043 container, 10044 anchor, 10045 parentComponent, 10046 parentSuspense, 10047 namespace, 10048 slotScopeIds, 10049 optimized, 10050 internals 10051 ); 10052 delete n1.el.__isMounted; 10053 }, parentSuspense); 10054 return; 10055 } 10056 n2.el = n1.el; 10057 n2.targetStart = n1.targetStart; 10058 const mainAnchor = n2.anchor = n1.anchor; 10059 const target = n2.target = n1.target; 10060 const targetAnchor = n2.targetAnchor = n1.targetAnchor; 10061 const wasDisabled = isTeleportDisabled(n1.props); 10062 const currentContainer = wasDisabled ? container : target; 10063 const currentAnchor = wasDisabled ? mainAnchor : targetAnchor; 10064 if (namespace === "svg" || isTargetSVG(target)) { 10065 namespace = "svg"; 10066 } else if (namespace === "mathml" || isTargetMathML(target)) { 10067 namespace = "mathml"; 10068 } 10069 if (dynamicChildren) { 10070 patchBlockChildren( 10071 n1.dynamicChildren, 10072 dynamicChildren, 10073 currentContainer, 10074 parentComponent, 10075 parentSuspense, 10076 namespace, 10077 slotScopeIds 10078 ); 10079 traverseStaticChildren(n1, n2, true); 10080 } else if (!optimized) { 10081 patchChildren( 10082 n1, 10083 n2, 10084 currentContainer, 10085 currentAnchor, 10086 parentComponent, 10087 parentSuspense, 10088 namespace, 10089 slotScopeIds, 10090 false 10091 ); 10092 } 10093 if (disabled) { 10094 if (!wasDisabled) { 10095 moveTeleport( 10096 n2, 10097 container, 10098 mainAnchor, 10099 internals, 10100 1 10101 ); 10102 } else { 10103 if (n2.props && n1.props && n2.props.to !== n1.props.to) { 10104 n2.props.to = n1.props.to; 10105 } 10106 } 10107 } else { 10108 if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) { 10109 const nextTarget = n2.target = resolveTarget( 10110 n2.props, 10111 querySelector 10112 ); 10113 if (nextTarget) { 10114 moveTeleport( 10115 n2, 10116 nextTarget, 10117 null, 10118 internals, 10119 0 10120 ); 10121 } else if (true) { 10122 warn$1( 10123 "Invalid Teleport target on update:", 10124 target, 10125 `(${typeof target})` 10126 ); 10127 } 10128 } else if (wasDisabled) { 10129 moveTeleport( 10130 n2, 10131 target, 10132 targetAnchor, 10133 internals, 10134 1 10135 ); 10136 } 10137 } 10138 updateCssVars(n2, disabled); 10139 } 10140 }, 10141 remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) { 10142 const { 10143 shapeFlag, 10144 children, 10145 anchor, 10146 targetStart, 10147 targetAnchor, 10148 target, 10149 props 10150 } = vnode; 10151 if (target) { 10152 hostRemove(targetStart); 10153 hostRemove(targetAnchor); 10154 } 10155 doRemove && hostRemove(anchor); 10156 if (shapeFlag & 16) { 10157 const shouldRemove = doRemove || !isTeleportDisabled(props); 10158 for (let i = 0; i < children.length; i++) { 10159 const child = children[i]; 10160 unmount( 10161 child, 10162 parentComponent, 10163 parentSuspense, 10164 shouldRemove, 10165 !!child.dynamicChildren 10166 ); 10167 } 10168 } 10169 }, 10170 move: moveTeleport, 10171 hydrate: hydrateTeleport 10172}; 10173function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) { 10174 if (moveType === 0) { 10175 insert(vnode.targetAnchor, container, parentAnchor); 10176 } 10177 const { el, anchor, shapeFlag, children, props } = vnode; 10178 const isReorder = moveType === 2; 10179 if (isReorder) { 10180 insert(el, container, parentAnchor); 10181 } 10182 if (!isReorder || isTeleportDisabled(props)) { 10183 if (shapeFlag & 16) { 10184 for (let i = 0; i < children.length; i++) { 10185 move( 10186 children[i], 10187 container, 10188 parentAnchor, 10189 2 10190 ); 10191 } 10192 } 10193 } 10194 if (isReorder) { 10195 insert(anchor, container, parentAnchor); 10196 } 10197} 10198function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, { 10199 o: { nextSibling, parentNode, querySelector, insert, createText } 10200}, hydrateChildren) { 10201 const target = vnode.target = resolveTarget( 10202 vnode.props, 10203 querySelector 10204 ); 10205 if (target) { 10206 const disabled = isTeleportDisabled(vnode.props); 10207 const targetNode = target._lpa || target.firstChild; 10208 if (vnode.shapeFlag & 16) { 10209 if (disabled) { 10210 vnode.anchor = hydrateChildren( 10211 nextSibling(node), 10212 vnode, 10213 parentNode(node), 10214 parentComponent, 10215 parentSuspense, 10216 slotScopeIds, 10217 optimized 10218 ); 10219 vnode.targetStart = targetNode; 10220 vnode.targetAnchor = targetNode && nextSibling(targetNode); 10221 } else { 10222 vnode.anchor = nextSibling(node); 10223 let targetAnchor = targetNode; 10224 while (targetAnchor) { 10225 if (targetAnchor && targetAnchor.nodeType === 8) { 10226 if (targetAnchor.data === "teleport start anchor") { 10227 vnode.targetStart = targetAnchor; 10228 } else if (targetAnchor.data === "teleport anchor") { 10229 vnode.targetAnchor = targetAnchor; 10230 target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor); 10231 break; 10232 } 10233 } 10234 targetAnchor = nextSibling(targetAnchor); 10235 } 10236 if (!vnode.targetAnchor) { 10237 prepareAnchor(target, vnode, createText, insert); 10238 } 10239 hydrateChildren( 10240 targetNode && nextSibling(targetNode), 10241 vnode, 10242 target, 10243 parentComponent, 10244 parentSuspense, 10245 slotScopeIds, 10246 optimized 10247 ); 10248 } 10249 } 10250 updateCssVars(vnode, disabled); 10251 } 10252 return vnode.anchor && nextSibling(vnode.anchor); 10253} 10254const Teleport = TeleportImpl; 10255function updateCssVars(vnode, isDisabled) { 10256 const ctx = vnode.ctx; 10257 if (ctx && ctx.ut) { 10258 let node, anchor; 10259 if (isDisabled) { 10260 node = vnode.el; 10261 anchor = vnode.anchor; 10262 } else { 10263 node = vnode.targetStart; 10264 anchor = vnode.targetAnchor; 10265 } 10266 while (node && node !== anchor) { 10267 if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid); 10268 node = node.nextSibling; 10269 } 10270 ctx.ut(); 10271 } 10272} 10273function prepareAnchor(target, vnode, createText, insert) { 10274 const targetStart = vnode.targetStart = createText(""); 10275 const targetAnchor = vnode.targetAnchor = createText(""); 10276 targetStart[TeleportEndKey] = targetAnchor; 10277 if (target) { 10278 insert(targetStart, target); 10279 insert(targetAnchor, target); 10280 } 10281 return targetAnchor; 10282} 10283 10284const leaveCbKey = Symbol("_leaveCb"); 10285const enterCbKey = Symbol("_enterCb"); 10286function useTransitionState() { 10287 const state = { 10288 isMounted: false, 10289 isLeaving: false, 10290 isUnmounting: false, 10291 leavingVNodes: /* @__PURE__ */ new Map() 10292 }; 10293 onMounted(() => { 10294 state.isMounted = true; 10295 }); 10296 onBeforeUnmount(() => { 10297 state.isUnmounting = true; 10298 }); 10299 return state; 10300} 10301const TransitionHookValidator = [Function, Array]; 10302const BaseTransitionPropsValidators = { 10303 mode: String, 10304 appear: Boolean, 10305 persisted: Boolean, 10306 // enter 10307 onBeforeEnter: TransitionHookValidator, 10308 onEnter: TransitionHookValidator, 10309 onAfterEnter: TransitionHookValidator, 10310 onEnterCancelled: TransitionHookValidator, 10311 // leave 10312 onBeforeLeave: TransitionHookValidator, 10313 onLeave: TransitionHookValidator, 10314 onAfterLeave: TransitionHookValidator, 10315 onLeaveCancelled: TransitionHookValidator, 10316 // appear 10317 onBeforeAppear: TransitionHookValidator, 10318 onAppear: TransitionHookValidator, 10319 onAfterAppear: TransitionHookValidator, 10320 onAppearCancelled: TransitionHookValidator 10321}; 10322const recursiveGetSubtree = (instance) => { 10323 const subTree = instance.subTree; 10324 return subTree.component ? recursiveGetSubtree(subTree.component) : subTree; 10325}; 10326const BaseTransitionImpl = { 10327 name: `BaseTransition`, 10328 props: BaseTransitionPropsValidators, 10329 setup(props, { slots }) { 10330 const instance = getCurrentInstance(); 10331 const state = useTransitionState(); 10332 return () => { 10333 const children = slots.default && getTransitionRawChildren(slots.default(), true); 10334 if (!children || !children.length) { 10335 return; 10336 } 10337 const child = findNonCommentChild(children); 10338 const rawProps = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props); 10339 const { mode } = rawProps; 10340 if ( true && mode && mode !== "in-out" && mode !== "out-in" && mode !== "default") { 10341 warn$1(`invalid <transition> mode: ${mode}`); 10342 } 10343 if (state.isLeaving) { 10344 return emptyPlaceholder(child); 10345 } 10346 const innerChild = getInnerChild$1(child); 10347 if (!innerChild) { 10348 return emptyPlaceholder(child); 10349 } 10350 let enterHooks = resolveTransitionHooks( 10351 innerChild, 10352 rawProps, 10353 state, 10354 instance, 10355 // #11061, ensure enterHooks is fresh after clone 10356 (hooks) => enterHooks = hooks 10357 ); 10358 if (innerChild.type !== Comment) { 10359 setTransitionHooks(innerChild, enterHooks); 10360 } 10361 let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree); 10362 if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) { 10363 let leavingHooks = resolveTransitionHooks( 10364 oldInnerChild, 10365 rawProps, 10366 state, 10367 instance 10368 ); 10369 setTransitionHooks(oldInnerChild, leavingHooks); 10370 if (mode === "out-in" && innerChild.type !== Comment) { 10371 state.isLeaving = true; 10372 leavingHooks.afterLeave = () => { 10373 state.isLeaving = false; 10374 if (!(instance.job.flags & 8)) { 10375 instance.update(); 10376 } 10377 delete leavingHooks.afterLeave; 10378 oldInnerChild = void 0; 10379 }; 10380 return emptyPlaceholder(child); 10381 } else if (mode === "in-out" && innerChild.type !== Comment) { 10382 leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => { 10383 const leavingVNodesCache = getLeavingNodesForType( 10384 state, 10385 oldInnerChild 10386 ); 10387 leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild; 10388 el[leaveCbKey] = () => { 10389 earlyRemove(); 10390 el[leaveCbKey] = void 0; 10391 delete enterHooks.delayedLeave; 10392 oldInnerChild = void 0; 10393 }; 10394 enterHooks.delayedLeave = () => { 10395 delayedLeave(); 10396 delete enterHooks.delayedLeave; 10397 oldInnerChild = void 0; 10398 }; 10399 }; 10400 } else { 10401 oldInnerChild = void 0; 10402 } 10403 } else if (oldInnerChild) { 10404 oldInnerChild = void 0; 10405 } 10406 return child; 10407 }; 10408 } 10409}; 10410function findNonCommentChild(children) { 10411 let child = children[0]; 10412 if (children.length > 1) { 10413 let hasFound = false; 10414 for (const c of children) { 10415 if (c.type !== Comment) { 10416 if ( true && hasFound) { 10417 warn$1( 10418 "<transition> can only be used on a single element or component. Use <transition-group> for lists." 10419 ); 10420 break; 10421 } 10422 child = c; 10423 hasFound = true; 10424 if (false) {} 10425 } 10426 } 10427 } 10428 return child; 10429} 10430const BaseTransition = BaseTransitionImpl; 10431function getLeavingNodesForType(state, vnode) { 10432 const { leavingVNodes } = state; 10433 let leavingVNodesCache = leavingVNodes.get(vnode.type); 10434 if (!leavingVNodesCache) { 10435 leavingVNodesCache = /* @__PURE__ */ Object.create(null); 10436 leavingVNodes.set(vnode.type, leavingVNodesCache); 10437 } 10438 return leavingVNodesCache; 10439} 10440function resolveTransitionHooks(vnode, props, state, instance, postClone) { 10441 const { 10442 appear, 10443 mode, 10444 persisted = false, 10445 onBeforeEnter, 10446 onEnter, 10447 onAfterEnter, 10448 onEnterCancelled, 10449 onBeforeLeave, 10450 onLeave, 10451 onAfterLeave, 10452 onLeaveCancelled, 10453 onBeforeAppear, 10454 onAppear, 10455 onAfterAppear, 10456 onAppearCancelled 10457 } = props; 10458 const key = String(vnode.key); 10459 const leavingVNodesCache = getLeavingNodesForType(state, vnode); 10460 const callHook = (hook, args) => { 10461 hook && callWithAsyncErrorHandling( 10462 hook, 10463 instance, 10464 9, 10465 args 10466 ); 10467 }; 10468 const callAsyncHook = (hook, args) => { 10469 const done = args[1]; 10470 callHook(hook, args); 10471 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook)) { 10472 if (hook.every((hook2) => hook2.length <= 1)) done(); 10473 } else if (hook.length <= 1) { 10474 done(); 10475 } 10476 }; 10477 const hooks = { 10478 mode, 10479 persisted, 10480 beforeEnter(el) { 10481 let hook = onBeforeEnter; 10482 if (!state.isMounted) { 10483 if (appear) { 10484 hook = onBeforeAppear || onBeforeEnter; 10485 } else { 10486 return; 10487 } 10488 } 10489 if (el[leaveCbKey]) { 10490 el[leaveCbKey]( 10491 true 10492 /* cancelled */ 10493 ); 10494 } 10495 const leavingVNode = leavingVNodesCache[key]; 10496 if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) { 10497 leavingVNode.el[leaveCbKey](); 10498 } 10499 callHook(hook, [el]); 10500 }, 10501 enter(el) { 10502 let hook = onEnter; 10503 let afterHook = onAfterEnter; 10504 let cancelHook = onEnterCancelled; 10505 if (!state.isMounted) { 10506 if (appear) { 10507 hook = onAppear || onEnter; 10508 afterHook = onAfterAppear || onAfterEnter; 10509 cancelHook = onAppearCancelled || onEnterCancelled; 10510 } else { 10511 return; 10512 } 10513 } 10514 let called = false; 10515 const done = el[enterCbKey] = (cancelled) => { 10516 if (called) return; 10517 called = true; 10518 if (cancelled) { 10519 callHook(cancelHook, [el]); 10520 } else { 10521 callHook(afterHook, [el]); 10522 } 10523 if (hooks.delayedLeave) { 10524 hooks.delayedLeave(); 10525 } 10526 el[enterCbKey] = void 0; 10527 }; 10528 if (hook) { 10529 callAsyncHook(hook, [el, done]); 10530 } else { 10531 done(); 10532 } 10533 }, 10534 leave(el, remove) { 10535 const key2 = String(vnode.key); 10536 if (el[enterCbKey]) { 10537 el[enterCbKey]( 10538 true 10539 /* cancelled */ 10540 ); 10541 } 10542 if (state.isUnmounting) { 10543 return remove(); 10544 } 10545 callHook(onBeforeLeave, [el]); 10546 let called = false; 10547 const done = el[leaveCbKey] = (cancelled) => { 10548 if (called) return; 10549 called = true; 10550 remove(); 10551 if (cancelled) { 10552 callHook(onLeaveCancelled, [el]); 10553 } else { 10554 callHook(onAfterLeave, [el]); 10555 } 10556 el[leaveCbKey] = void 0; 10557 if (leavingVNodesCache[key2] === vnode) { 10558 delete leavingVNodesCache[key2]; 10559 } 10560 }; 10561 leavingVNodesCache[key2] = vnode; 10562 if (onLeave) { 10563 callAsyncHook(onLeave, [el, done]); 10564 } else { 10565 done(); 10566 } 10567 }, 10568 clone(vnode2) { 10569 const hooks2 = resolveTransitionHooks( 10570 vnode2, 10571 props, 10572 state, 10573 instance, 10574 postClone 10575 ); 10576 if (postClone) postClone(hooks2); 10577 return hooks2; 10578 } 10579 }; 10580 return hooks; 10581} 10582function emptyPlaceholder(vnode) { 10583 if (isKeepAlive(vnode)) { 10584 vnode = cloneVNode(vnode); 10585 vnode.children = null; 10586 return vnode; 10587 } 10588} 10589function getInnerChild$1(vnode) { 10590 if (!isKeepAlive(vnode)) { 10591 if (isTeleport(vnode.type) && vnode.children) { 10592 return findNonCommentChild(vnode.children); 10593 } 10594 return vnode; 10595 } 10596 if ( true && vnode.component) { 10597 return vnode.component.subTree; 10598 } 10599 const { shapeFlag, children } = vnode; 10600 if (children) { 10601 if (shapeFlag & 16) { 10602 return children[0]; 10603 } 10604 if (shapeFlag & 32 && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(children.default)) { 10605 return children.default(); 10606 } 10607 } 10608} 10609function setTransitionHooks(vnode, hooks) { 10610 if (vnode.shapeFlag & 6 && vnode.component) { 10611 vnode.transition = hooks; 10612 setTransitionHooks(vnode.component.subTree, hooks); 10613 } else if (vnode.shapeFlag & 128) { 10614 vnode.ssContent.transition = hooks.clone(vnode.ssContent); 10615 vnode.ssFallback.transition = hooks.clone(vnode.ssFallback); 10616 } else { 10617 vnode.transition = hooks; 10618 } 10619} 10620function getTransitionRawChildren(children, keepComment = false, parentKey) { 10621 let ret = []; 10622 let keyedFragmentCount = 0; 10623 for (let i = 0; i < children.length; i++) { 10624 let child = children[i]; 10625 const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i); 10626 if (child.type === Fragment) { 10627 if (child.patchFlag & 128) keyedFragmentCount++; 10628 ret = ret.concat( 10629 getTransitionRawChildren(child.children, keepComment, key) 10630 ); 10631 } else if (keepComment || child.type !== Comment) { 10632 ret.push(key != null ? cloneVNode(child, { key }) : child); 10633 } 10634 } 10635 if (keyedFragmentCount > 1) { 10636 for (let i = 0; i < ret.length; i++) { 10637 ret[i].patchFlag = -2; 10638 } 10639 } 10640 return ret; 10641} 10642 10643/*! #__NO_SIDE_EFFECTS__ */ 10644// @__NO_SIDE_EFFECTS__ 10645function defineComponent(options, extraOptions) { 10646 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(options) ? ( 10647 // #8236: extend call and options.name access are considered side-effects 10648 // by Rollup, so we have to wrap it in a pure-annotated IIFE. 10649 /* @__PURE__ */ (() => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({ name: options.name }, extraOptions, { setup: options }))() 10650 ) : options; 10651} 10652 10653function useId() { 10654 const i = getCurrentInstance(); 10655 if (i) { 10656 return (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++; 10657 } else if (true) { 10658 warn$1( 10659 `useId() is called when there is no active component instance to be associated with.` 10660 ); 10661 } 10662 return ""; 10663} 10664function markAsyncBoundary(instance) { 10665 instance.ids = [instance.ids[0] + instance.ids[2]++ + "-", 0, 0]; 10666} 10667 10668const knownTemplateRefs = /* @__PURE__ */ new WeakSet(); 10669function useTemplateRef(key) { 10670 const i = getCurrentInstance(); 10671 const r = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowRef)(null); 10672 if (i) { 10673 const refs = i.refs === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ ? i.refs = {} : i.refs; 10674 let desc; 10675 if ( true && (desc = Object.getOwnPropertyDescriptor(refs, key)) && !desc.configurable) { 10676 warn$1(`useTemplateRef('${key}') already exists.`); 10677 } else { 10678 Object.defineProperty(refs, key, { 10679 enumerable: true, 10680 get: () => r.value, 10681 set: (val) => r.value = val 10682 }); 10683 } 10684 } else if (true) { 10685 warn$1( 10686 `useTemplateRef() is called when there is no active component instance to be associated with.` 10687 ); 10688 } 10689 const ret = true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.readonly)(r) : 0; 10690 if (true) { 10691 knownTemplateRefs.add(ret); 10692 } 10693 return ret; 10694} 10695 10696function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) { 10697 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(rawRef)) { 10698 rawRef.forEach( 10699 (r, i) => setRef( 10700 r, 10701 oldRawRef && ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(oldRawRef) ? oldRawRef[i] : oldRawRef), 10702 parentSuspense, 10703 vnode, 10704 isUnmount 10705 ) 10706 ); 10707 return; 10708 } 10709 if (isAsyncWrapper(vnode) && !isUnmount) { 10710 if (vnode.shapeFlag & 512 && vnode.type.__asyncResolved && vnode.component.subTree.component) { 10711 setRef(rawRef, oldRawRef, parentSuspense, vnode.component.subTree); 10712 } 10713 return; 10714 } 10715 const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el; 10716 const value = isUnmount ? null : refValue; 10717 const { i: owner, r: ref } = rawRef; 10718 if ( true && !owner) { 10719 warn$1( 10720 `Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.` 10721 ); 10722 return; 10723 } 10724 const oldRef = oldRawRef && oldRawRef.r; 10725 const refs = owner.refs === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ ? owner.refs = {} : owner.refs; 10726 const setupState = owner.setupState; 10727 const rawSetupState = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(setupState); 10728 const canSetSetupRef = setupState === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ ? () => false : (key) => { 10729 if (true) { 10730 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawSetupState, key) && !(0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(rawSetupState[key])) { 10731 warn$1( 10732 `Template ref "${key}" used on a non-ref value. It will not work in the production build.` 10733 ); 10734 } 10735 if (knownTemplateRefs.has(rawSetupState[key])) { 10736 return false; 10737 } 10738 } 10739 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawSetupState, key); 10740 }; 10741 if (oldRef != null && oldRef !== ref) { 10742 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(oldRef)) { 10743 refs[oldRef] = null; 10744 if (canSetSetupRef(oldRef)) { 10745 setupState[oldRef] = null; 10746 } 10747 } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(oldRef)) { 10748 oldRef.value = null; 10749 } 10750 } 10751 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(ref)) { 10752 callWithErrorHandling(ref, owner, 12, [value, refs]); 10753 } else { 10754 const _isString = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(ref); 10755 const _isRef = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(ref); 10756 if (_isString || _isRef) { 10757 const doSet = () => { 10758 if (rawRef.f) { 10759 const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : ref.value; 10760 if (isUnmount) { 10761 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(existing) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.remove)(existing, refValue); 10762 } else { 10763 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(existing)) { 10764 if (_isString) { 10765 refs[ref] = [refValue]; 10766 if (canSetSetupRef(ref)) { 10767 setupState[ref] = refs[ref]; 10768 } 10769 } else { 10770 ref.value = [refValue]; 10771 if (rawRef.k) refs[rawRef.k] = ref.value; 10772 } 10773 } else if (!existing.includes(refValue)) { 10774 existing.push(refValue); 10775 } 10776 } 10777 } else if (_isString) { 10778 refs[ref] = value; 10779 if (canSetSetupRef(ref)) { 10780 setupState[ref] = value; 10781 } 10782 } else if (_isRef) { 10783 ref.value = value; 10784 if (rawRef.k) refs[rawRef.k] = value; 10785 } else if (true) { 10786 warn$1("Invalid template ref type:", ref, `(${typeof ref})`); 10787 } 10788 }; 10789 if (value) { 10790 doSet.id = -1; 10791 queuePostRenderEffect(doSet, parentSuspense); 10792 } else { 10793 doSet(); 10794 } 10795 } else if (true) { 10796 warn$1("Invalid template ref type:", ref, `(${typeof ref})`); 10797 } 10798 } 10799} 10800 10801let hasLoggedMismatchError = false; 10802const logMismatchError = () => { 10803 if (hasLoggedMismatchError) { 10804 return; 10805 } 10806 console.error("Hydration completed but contains mismatches."); 10807 hasLoggedMismatchError = true; 10808}; 10809const isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject"; 10810const isMathMLContainer = (container) => container.namespaceURI.includes("MathML"); 10811const getContainerType = (container) => { 10812 if (container.nodeType !== 1) return void 0; 10813 if (isSVGContainer(container)) return "svg"; 10814 if (isMathMLContainer(container)) return "mathml"; 10815 return void 0; 10816}; 10817const isComment = (node) => node.nodeType === 8; 10818function createHydrationFunctions(rendererInternals) { 10819 const { 10820 mt: mountComponent, 10821 p: patch, 10822 o: { 10823 patchProp, 10824 createText, 10825 nextSibling, 10826 parentNode, 10827 remove, 10828 insert, 10829 createComment 10830 } 10831 } = rendererInternals; 10832 const hydrate = (vnode, container) => { 10833 if (!container.hasChildNodes()) { 10834 ( true) && warn$1( 10835 `Attempting to hydrate existing markup but container is empty. Performing full mount instead.` 10836 ); 10837 patch(null, vnode, container); 10838 flushPostFlushCbs(); 10839 container._vnode = vnode; 10840 return; 10841 } 10842 hydrateNode(container.firstChild, vnode, null, null, null); 10843 flushPostFlushCbs(); 10844 container._vnode = vnode; 10845 }; 10846 const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => { 10847 optimized = optimized || !!vnode.dynamicChildren; 10848 const isFragmentStart = isComment(node) && node.data === "["; 10849 const onMismatch = () => handleMismatch( 10850 node, 10851 vnode, 10852 parentComponent, 10853 parentSuspense, 10854 slotScopeIds, 10855 isFragmentStart 10856 ); 10857 const { type, ref, shapeFlag, patchFlag } = vnode; 10858 let domType = node.nodeType; 10859 vnode.el = node; 10860 if (true) { 10861 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(node, "__vnode", vnode, true); 10862 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(node, "__vueParentComponent", parentComponent, true); 10863 } 10864 if (patchFlag === -2) { 10865 optimized = false; 10866 vnode.dynamicChildren = null; 10867 } 10868 let nextNode = null; 10869 switch (type) { 10870 case Text: 10871 if (domType !== 3) { 10872 if (vnode.children === "") { 10873 insert(vnode.el = createText(""), parentNode(node), node); 10874 nextNode = node; 10875 } else { 10876 nextNode = onMismatch(); 10877 } 10878 } else { 10879 if (node.data !== vnode.children) { 10880 ( true) && warn$1( 10881 `Hydration text mismatch in`, 10882 node.parentNode, 10883 ` 10884 - rendered on server: ${JSON.stringify( 10885 node.data 10886 )} 10887 - expected on client: ${JSON.stringify(vnode.children)}` 10888 ); 10889 logMismatchError(); 10890 node.data = vnode.children; 10891 } 10892 nextNode = nextSibling(node); 10893 } 10894 break; 10895 case Comment: 10896 if (isTemplateNode(node)) { 10897 nextNode = nextSibling(node); 10898 replaceNode( 10899 vnode.el = node.content.firstChild, 10900 node, 10901 parentComponent 10902 ); 10903 } else if (domType !== 8 || isFragmentStart) { 10904 nextNode = onMismatch(); 10905 } else { 10906 nextNode = nextSibling(node); 10907 } 10908 break; 10909 case Static: 10910 if (isFragmentStart) { 10911 node = nextSibling(node); 10912 domType = node.nodeType; 10913 } 10914 if (domType === 1 || domType === 3) { 10915 nextNode = node; 10916 const needToAdoptContent = !vnode.children.length; 10917 for (let i = 0; i < vnode.staticCount; i++) { 10918 if (needToAdoptContent) 10919 vnode.children += nextNode.nodeType === 1 ? nextNode.outerHTML : nextNode.data; 10920 if (i === vnode.staticCount - 1) { 10921 vnode.anchor = nextNode; 10922 } 10923 nextNode = nextSibling(nextNode); 10924 } 10925 return isFragmentStart ? nextSibling(nextNode) : nextNode; 10926 } else { 10927 onMismatch(); 10928 } 10929 break; 10930 case Fragment: 10931 if (!isFragmentStart) { 10932 nextNode = onMismatch(); 10933 } else { 10934 nextNode = hydrateFragment( 10935 node, 10936 vnode, 10937 parentComponent, 10938 parentSuspense, 10939 slotScopeIds, 10940 optimized 10941 ); 10942 } 10943 break; 10944 default: 10945 if (shapeFlag & 1) { 10946 if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) { 10947 nextNode = onMismatch(); 10948 } else { 10949 nextNode = hydrateElement( 10950 node, 10951 vnode, 10952 parentComponent, 10953 parentSuspense, 10954 slotScopeIds, 10955 optimized 10956 ); 10957 } 10958 } else if (shapeFlag & 6) { 10959 vnode.slotScopeIds = slotScopeIds; 10960 const container = parentNode(node); 10961 if (isFragmentStart) { 10962 nextNode = locateClosingAnchor(node); 10963 } else if (isComment(node) && node.data === "teleport start") { 10964 nextNode = locateClosingAnchor(node, node.data, "teleport end"); 10965 } else { 10966 nextNode = nextSibling(node); 10967 } 10968 mountComponent( 10969 vnode, 10970 container, 10971 null, 10972 parentComponent, 10973 parentSuspense, 10974 getContainerType(container), 10975 optimized 10976 ); 10977 if (isAsyncWrapper(vnode) && !vnode.type.__asyncResolved) { 10978 let subTree; 10979 if (isFragmentStart) { 10980 subTree = createVNode(Fragment); 10981 subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild; 10982 } else { 10983 subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div"); 10984 } 10985 subTree.el = node; 10986 vnode.component.subTree = subTree; 10987 } 10988 } else if (shapeFlag & 64) { 10989 if (domType !== 8) { 10990 nextNode = onMismatch(); 10991 } else { 10992 nextNode = vnode.type.hydrate( 10993 node, 10994 vnode, 10995 parentComponent, 10996 parentSuspense, 10997 slotScopeIds, 10998 optimized, 10999 rendererInternals, 11000 hydrateChildren 11001 ); 11002 } 11003 } else if (shapeFlag & 128) { 11004 nextNode = vnode.type.hydrate( 11005 node, 11006 vnode, 11007 parentComponent, 11008 parentSuspense, 11009 getContainerType(parentNode(node)), 11010 slotScopeIds, 11011 optimized, 11012 rendererInternals, 11013 hydrateNode 11014 ); 11015 } else if (true) { 11016 warn$1("Invalid HostVNode type:", type, `(${typeof type})`); 11017 } 11018 } 11019 if (ref != null) { 11020 setRef(ref, null, parentSuspense, vnode); 11021 } 11022 return nextNode; 11023 }; 11024 const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { 11025 optimized = optimized || !!vnode.dynamicChildren; 11026 const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode; 11027 const forcePatch = type === "input" || type === "option"; 11028 if (true) { 11029 if (dirs) { 11030 invokeDirectiveHook(vnode, null, parentComponent, "created"); 11031 } 11032 let needCallTransitionHooks = false; 11033 if (isTemplateNode(el)) { 11034 needCallTransitionHooks = needTransition( 11035 null, 11036 // no need check parentSuspense in hydration 11037 transition 11038 ) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear; 11039 const content = el.content.firstChild; 11040 if (needCallTransitionHooks) { 11041 transition.beforeEnter(content); 11042 } 11043 replaceNode(content, el, parentComponent); 11044 vnode.el = el = content; 11045 } 11046 if (shapeFlag & 16 && // skip if element has innerHTML / textContent 11047 !(props && (props.innerHTML || props.textContent))) { 11048 let next = hydrateChildren( 11049 el.firstChild, 11050 vnode, 11051 el, 11052 parentComponent, 11053 parentSuspense, 11054 slotScopeIds, 11055 optimized 11056 ); 11057 let hasWarned = false; 11058 while (next) { 11059 if (!isMismatchAllowed(el, 1 /* CHILDREN */)) { 11060 if (( true) && !hasWarned) { 11061 warn$1( 11062 `Hydration children mismatch on`, 11063 el, 11064 ` 11065Server rendered element contains more child nodes than client vdom.` 11066 ); 11067 hasWarned = true; 11068 } 11069 logMismatchError(); 11070 } 11071 const cur = next; 11072 next = next.nextSibling; 11073 remove(cur); 11074 } 11075 } else if (shapeFlag & 8) { 11076 let clientText = vnode.children; 11077 if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) { 11078 clientText = clientText.slice(1); 11079 } 11080 if (el.textContent !== clientText) { 11081 if (!isMismatchAllowed(el, 0 /* TEXT */)) { 11082 ( true) && warn$1( 11083 `Hydration text content mismatch on`, 11084 el, 11085 ` 11086 - rendered on server: ${el.textContent} 11087 - expected on client: ${vnode.children}` 11088 ); 11089 logMismatchError(); 11090 } 11091 el.textContent = vnode.children; 11092 } 11093 } 11094 if (props) { 11095 if (true) { 11096 const isCustomElement = el.tagName.includes("-"); 11097 for (const key in props) { 11098 if (( true) && // #11189 skip if this node has directives that have created hooks 11099 // as it could have mutated the DOM in any possible way 11100 !(dirs && dirs.some((d) => d.dir.created)) && propHasMismatch(el, key, props[key], vnode, parentComponent)) { 11101 logMismatchError(); 11102 } 11103 if (forcePatch && (key.endsWith("value") || key === "indeterminate") || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key) || // force hydrate v-bind with .prop modifiers 11104 key[0] === "." || isCustomElement) { 11105 patchProp(el, key, null, props[key], void 0, parentComponent); 11106 } 11107 } 11108 } else {} 11109 } 11110 let vnodeHooks; 11111 if (vnodeHooks = props && props.onVnodeBeforeMount) { 11112 invokeVNodeHook(vnodeHooks, parentComponent, vnode); 11113 } 11114 if (dirs) { 11115 invokeDirectiveHook(vnode, null, parentComponent, "beforeMount"); 11116 } 11117 if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) { 11118 queueEffectWithSuspense(() => { 11119 vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode); 11120 needCallTransitionHooks && transition.enter(el); 11121 dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted"); 11122 }, parentSuspense); 11123 } 11124 } 11125 return el.nextSibling; 11126 }; 11127 const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => { 11128 optimized = optimized || !!parentVNode.dynamicChildren; 11129 const children = parentVNode.children; 11130 const l = children.length; 11131 let hasWarned = false; 11132 for (let i = 0; i < l; i++) { 11133 const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]); 11134 const isText = vnode.type === Text; 11135 if (node) { 11136 if (isText && !optimized) { 11137 if (i + 1 < l && normalizeVNode(children[i + 1]).type === Text) { 11138 insert( 11139 createText( 11140 node.data.slice(vnode.children.length) 11141 ), 11142 container, 11143 nextSibling(node) 11144 ); 11145 node.data = vnode.children; 11146 } 11147 } 11148 node = hydrateNode( 11149 node, 11150 vnode, 11151 parentComponent, 11152 parentSuspense, 11153 slotScopeIds, 11154 optimized 11155 ); 11156 } else if (isText && !vnode.children) { 11157 insert(vnode.el = createText(""), container); 11158 } else { 11159 if (!isMismatchAllowed(container, 1 /* CHILDREN */)) { 11160 if (( true) && !hasWarned) { 11161 warn$1( 11162 `Hydration children mismatch on`, 11163 container, 11164 ` 11165Server rendered element contains fewer child nodes than client vdom.` 11166 ); 11167 hasWarned = true; 11168 } 11169 logMismatchError(); 11170 } 11171 patch( 11172 null, 11173 vnode, 11174 container, 11175 null, 11176 parentComponent, 11177 parentSuspense, 11178 getContainerType(container), 11179 slotScopeIds 11180 ); 11181 } 11182 } 11183 return node; 11184 }; 11185 const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { 11186 const { slotScopeIds: fragmentSlotScopeIds } = vnode; 11187 if (fragmentSlotScopeIds) { 11188 slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds; 11189 } 11190 const container = parentNode(node); 11191 const next = hydrateChildren( 11192 nextSibling(node), 11193 vnode, 11194 container, 11195 parentComponent, 11196 parentSuspense, 11197 slotScopeIds, 11198 optimized 11199 ); 11200 if (next && isComment(next) && next.data === "]") { 11201 return nextSibling(vnode.anchor = next); 11202 } else { 11203 logMismatchError(); 11204 insert(vnode.anchor = createComment(`]`), container, next); 11205 return next; 11206 } 11207 }; 11208 const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => { 11209 if (!isMismatchAllowed(node.parentElement, 1 /* CHILDREN */)) { 11210 ( true) && warn$1( 11211 `Hydration node mismatch: 11212- rendered on server:`, 11213 node, 11214 node.nodeType === 3 ? `(text)` : isComment(node) && node.data === "[" ? `(start of fragment)` : ``, 11215 ` 11216- expected on client:`, 11217 vnode.type 11218 ); 11219 logMismatchError(); 11220 } 11221 vnode.el = null; 11222 if (isFragment) { 11223 const end = locateClosingAnchor(node); 11224 while (true) { 11225 const next2 = nextSibling(node); 11226 if (next2 && next2 !== end) { 11227 remove(next2); 11228 } else { 11229 break; 11230 } 11231 } 11232 } 11233 const next = nextSibling(node); 11234 const container = parentNode(node); 11235 remove(node); 11236 patch( 11237 null, 11238 vnode, 11239 container, 11240 next, 11241 parentComponent, 11242 parentSuspense, 11243 getContainerType(container), 11244 slotScopeIds 11245 ); 11246 if (parentComponent) { 11247 parentComponent.vnode.el = vnode.el; 11248 updateHOCHostEl(parentComponent, vnode.el); 11249 } 11250 return next; 11251 }; 11252 const locateClosingAnchor = (node, open = "[", close = "]") => { 11253 let match = 0; 11254 while (node) { 11255 node = nextSibling(node); 11256 if (node && isComment(node)) { 11257 if (node.data === open) match++; 11258 if (node.data === close) { 11259 if (match === 0) { 11260 return nextSibling(node); 11261 } else { 11262 match--; 11263 } 11264 } 11265 } 11266 } 11267 return node; 11268 }; 11269 const replaceNode = (newNode, oldNode, parentComponent) => { 11270 const parentNode2 = oldNode.parentNode; 11271 if (parentNode2) { 11272 parentNode2.replaceChild(newNode, oldNode); 11273 } 11274 let parent = parentComponent; 11275 while (parent) { 11276 if (parent.vnode.el === oldNode) { 11277 parent.vnode.el = parent.subTree.el = newNode; 11278 } 11279 parent = parent.parent; 11280 } 11281 }; 11282 const isTemplateNode = (node) => { 11283 return node.nodeType === 1 && node.tagName === "TEMPLATE"; 11284 }; 11285 return [hydrate, hydrateNode]; 11286} 11287function propHasMismatch(el, key, clientValue, vnode, instance) { 11288 let mismatchType; 11289 let mismatchKey; 11290 let actual; 11291 let expected; 11292 if (key === "class") { 11293 actual = el.getAttribute("class"); 11294 expected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass)(clientValue); 11295 if (!isSetEqual(toClassSet(actual || ""), toClassSet(expected))) { 11296 mismatchType = 2 /* CLASS */; 11297 mismatchKey = `class`; 11298 } 11299 } else if (key === "style") { 11300 actual = el.getAttribute("style") || ""; 11301 expected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(clientValue) ? clientValue : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.stringifyStyle)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle)(clientValue)); 11302 const actualMap = toStyleMap(actual); 11303 const expectedMap = toStyleMap(expected); 11304 if (vnode.dirs) { 11305 for (const { dir, value } of vnode.dirs) { 11306 if (dir.name === "show" && !value) { 11307 expectedMap.set("display", "none"); 11308 } 11309 } 11310 } 11311 if (instance) { 11312 resolveCssVars(instance, vnode, expectedMap); 11313 } 11314 if (!isMapEqual(actualMap, expectedMap)) { 11315 mismatchType = 3 /* STYLE */; 11316 mismatchKey = "style"; 11317 } 11318 } else if (el instanceof SVGElement && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isKnownSvgAttr)(key) || el instanceof HTMLElement && ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isBooleanAttr)(key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isKnownHtmlAttr)(key))) { 11319 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isBooleanAttr)(key)) { 11320 actual = el.hasAttribute(key); 11321 expected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.includeBooleanAttr)(clientValue); 11322 } else if (clientValue == null) { 11323 actual = el.hasAttribute(key); 11324 expected = false; 11325 } else { 11326 if (el.hasAttribute(key)) { 11327 actual = el.getAttribute(key); 11328 } else if (key === "value" && el.tagName === "TEXTAREA") { 11329 actual = el.value; 11330 } else { 11331 actual = false; 11332 } 11333 expected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isRenderableAttrValue)(clientValue) ? String(clientValue) : false; 11334 } 11335 if (actual !== expected) { 11336 mismatchType = 4 /* ATTRIBUTE */; 11337 mismatchKey = key; 11338 } 11339 } 11340 if (mismatchType != null && !isMismatchAllowed(el, mismatchType)) { 11341 const format = (v) => v === false ? `(not rendered)` : `${mismatchKey}="${v}"`; 11342 const preSegment = `Hydration ${MismatchTypeString[mismatchType]} mismatch on`; 11343 const postSegment = ` 11344 - rendered on server: ${format(actual)} 11345 - expected on client: ${format(expected)} 11346 Note: this mismatch is check-only. The DOM will not be rectified in production due to performance overhead. 11347 You should fix the source of the mismatch.`; 11348 { 11349 warn$1(preSegment, el, postSegment); 11350 } 11351 return true; 11352 } 11353 return false; 11354} 11355function toClassSet(str) { 11356 return new Set(str.trim().split(/\s+/)); 11357} 11358function isSetEqual(a, b) { 11359 if (a.size !== b.size) { 11360 return false; 11361 } 11362 for (const s of a) { 11363 if (!b.has(s)) { 11364 return false; 11365 } 11366 } 11367 return true; 11368} 11369function toStyleMap(str) { 11370 const styleMap = /* @__PURE__ */ new Map(); 11371 for (const item of str.split(";")) { 11372 let [key, value] = item.split(":"); 11373 key = key.trim(); 11374 value = value && value.trim(); 11375 if (key && value) { 11376 styleMap.set(key, value); 11377 } 11378 } 11379 return styleMap; 11380} 11381function isMapEqual(a, b) { 11382 if (a.size !== b.size) { 11383 return false; 11384 } 11385 for (const [key, value] of a) { 11386 if (value !== b.get(key)) { 11387 return false; 11388 } 11389 } 11390 return true; 11391} 11392function resolveCssVars(instance, vnode, expectedMap) { 11393 const root = instance.subTree; 11394 if (instance.getCssVars && (vnode === root || root && root.type === Fragment && root.children.includes(vnode))) { 11395 const cssVars = instance.getCssVars(); 11396 for (const key in cssVars) { 11397 expectedMap.set( 11398 `--${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getEscapedCssVarName)(key, false)}`, 11399 String(cssVars[key]) 11400 ); 11401 } 11402 } 11403 if (vnode === root && instance.parent) { 11404 resolveCssVars(instance.parent, instance.vnode, expectedMap); 11405 } 11406} 11407const allowMismatchAttr = "data-allow-mismatch"; 11408const MismatchTypeString = { 11409 [0 /* TEXT */]: "text", 11410 [1 /* CHILDREN */]: "children", 11411 [2 /* CLASS */]: "class", 11412 [3 /* STYLE */]: "style", 11413 [4 /* ATTRIBUTE */]: "attribute" 11414}; 11415function isMismatchAllowed(el, allowedType) { 11416 if (allowedType === 0 /* TEXT */ || allowedType === 1 /* CHILDREN */) { 11417 while (el && !el.hasAttribute(allowMismatchAttr)) { 11418 el = el.parentElement; 11419 } 11420 } 11421 const allowedAttr = el && el.getAttribute(allowMismatchAttr); 11422 if (allowedAttr == null) { 11423 return false; 11424 } else if (allowedAttr === "") { 11425 return true; 11426 } else { 11427 const list = allowedAttr.split(","); 11428 if (allowedType === 0 /* TEXT */ && list.includes("children")) { 11429 return true; 11430 } 11431 return allowedAttr.split(",").includes(MismatchTypeString[allowedType]); 11432 } 11433} 11434 11435const requestIdleCallback = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)().requestIdleCallback || ((cb) => setTimeout(cb, 1)); 11436const cancelIdleCallback = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)().cancelIdleCallback || ((id) => clearTimeout(id)); 11437const hydrateOnIdle = (timeout = 1e4) => (hydrate) => { 11438 const id = requestIdleCallback(hydrate, { timeout }); 11439 return () => cancelIdleCallback(id); 11440}; 11441function elementIsVisibleInViewport(el) { 11442 const { top, left, bottom, right } = el.getBoundingClientRect(); 11443 const { innerHeight, innerWidth } = window; 11444 return (top > 0 && top < innerHeight || bottom > 0 && bottom < innerHeight) && (left > 0 && left < innerWidth || right > 0 && right < innerWidth); 11445} 11446const hydrateOnVisible = (opts) => (hydrate, forEach) => { 11447 const ob = new IntersectionObserver((entries) => { 11448 for (const e of entries) { 11449 if (!e.isIntersecting) continue; 11450 ob.disconnect(); 11451 hydrate(); 11452 break; 11453 } 11454 }, opts); 11455 forEach((el) => { 11456 if (!(el instanceof Element)) return; 11457 if (elementIsVisibleInViewport(el)) { 11458 hydrate(); 11459 ob.disconnect(); 11460 return false; 11461 } 11462 ob.observe(el); 11463 }); 11464 return () => ob.disconnect(); 11465}; 11466const hydrateOnMediaQuery = (query) => (hydrate) => { 11467 if (query) { 11468 const mql = matchMedia(query); 11469 if (mql.matches) { 11470 hydrate(); 11471 } else { 11472 mql.addEventListener("change", hydrate, { once: true }); 11473 return () => mql.removeEventListener("change", hydrate); 11474 } 11475 } 11476}; 11477const hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => { 11478 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(interactions)) interactions = [interactions]; 11479 let hasHydrated = false; 11480 const doHydrate = (e) => { 11481 if (!hasHydrated) { 11482 hasHydrated = true; 11483 teardown(); 11484 hydrate(); 11485 e.target.dispatchEvent(new e.constructor(e.type, e)); 11486 } 11487 }; 11488 const teardown = () => { 11489 forEach((el) => { 11490 for (const i of interactions) { 11491 el.removeEventListener(i, doHydrate); 11492 } 11493 }); 11494 }; 11495 forEach((el) => { 11496 for (const i of interactions) { 11497 el.addEventListener(i, doHydrate, { once: true }); 11498 } 11499 }); 11500 return teardown; 11501}; 11502function forEachElement(node, cb) { 11503 if (isComment(node) && node.data === "[") { 11504 let depth = 1; 11505 let next = node.nextSibling; 11506 while (next) { 11507 if (next.nodeType === 1) { 11508 const result = cb(next); 11509 if (result === false) { 11510 break; 11511 } 11512 } else if (isComment(next)) { 11513 if (next.data === "]") { 11514 if (--depth === 0) break; 11515 } else if (next.data === "[") { 11516 depth++; 11517 } 11518 } 11519 next = next.nextSibling; 11520 } 11521 } else { 11522 cb(node); 11523 } 11524} 11525 11526const isAsyncWrapper = (i) => !!i.type.__asyncLoader; 11527/*! #__NO_SIDE_EFFECTS__ */ 11528// @__NO_SIDE_EFFECTS__ 11529function defineAsyncComponent(source) { 11530 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(source)) { 11531 source = { loader: source }; 11532 } 11533 const { 11534 loader, 11535 loadingComponent, 11536 errorComponent, 11537 delay = 200, 11538 hydrate: hydrateStrategy, 11539 timeout, 11540 // undefined = never times out 11541 suspensible = true, 11542 onError: userOnError 11543 } = source; 11544 let pendingRequest = null; 11545 let resolvedComp; 11546 let retries = 0; 11547 const retry = () => { 11548 retries++; 11549 pendingRequest = null; 11550 return load(); 11551 }; 11552 const load = () => { 11553 let thisRequest; 11554 return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => { 11555 err = err instanceof Error ? err : new Error(String(err)); 11556 if (userOnError) { 11557 return new Promise((resolve, reject) => { 11558 const userRetry = () => resolve(retry()); 11559 const userFail = () => reject(err); 11560 userOnError(err, userRetry, userFail, retries + 1); 11561 }); 11562 } else { 11563 throw err; 11564 } 11565 }).then((comp) => { 11566 if (thisRequest !== pendingRequest && pendingRequest) { 11567 return pendingRequest; 11568 } 11569 if ( true && !comp) { 11570 warn$1( 11571 `Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.` 11572 ); 11573 } 11574 if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) { 11575 comp = comp.default; 11576 } 11577 if ( true && comp && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(comp)) { 11578 throw new Error(`Invalid async component load result: ${comp}`); 11579 } 11580 resolvedComp = comp; 11581 return comp; 11582 })); 11583 }; 11584 return defineComponent({ 11585 name: "AsyncComponentWrapper", 11586 __asyncLoader: load, 11587 __asyncHydrate(el, instance, hydrate) { 11588 const doHydrate = hydrateStrategy ? () => { 11589 const teardown = hydrateStrategy( 11590 hydrate, 11591 (cb) => forEachElement(el, cb) 11592 ); 11593 if (teardown) { 11594 (instance.bum || (instance.bum = [])).push(teardown); 11595 } 11596 } : hydrate; 11597 if (resolvedComp) { 11598 doHydrate(); 11599 } else { 11600 load().then(() => !instance.isUnmounted && doHydrate()); 11601 } 11602 }, 11603 get __asyncResolved() { 11604 return resolvedComp; 11605 }, 11606 setup() { 11607 const instance = currentInstance; 11608 markAsyncBoundary(instance); 11609 if (resolvedComp) { 11610 return () => createInnerComp(resolvedComp, instance); 11611 } 11612 const onError = (err) => { 11613 pendingRequest = null; 11614 handleError( 11615 err, 11616 instance, 11617 13, 11618 !errorComponent 11619 ); 11620 }; 11621 if (suspensible && instance.suspense || isInSSRComponentSetup) { 11622 return load().then((comp) => { 11623 return () => createInnerComp(comp, instance); 11624 }).catch((err) => { 11625 onError(err); 11626 return () => errorComponent ? createVNode(errorComponent, { 11627 error: err 11628 }) : null; 11629 }); 11630 } 11631 const loaded = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)(false); 11632 const error = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)(); 11633 const delayed = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)(!!delay); 11634 if (delay) { 11635 setTimeout(() => { 11636 delayed.value = false; 11637 }, delay); 11638 } 11639 if (timeout != null) { 11640 setTimeout(() => { 11641 if (!loaded.value && !error.value) { 11642 const err = new Error( 11643 `Async component timed out after ${timeout}ms.` 11644 ); 11645 onError(err); 11646 error.value = err; 11647 } 11648 }, timeout); 11649 } 11650 load().then(() => { 11651 loaded.value = true; 11652 if (instance.parent && isKeepAlive(instance.parent.vnode)) { 11653 instance.parent.update(); 11654 } 11655 }).catch((err) => { 11656 onError(err); 11657 error.value = err; 11658 }); 11659 return () => { 11660 if (loaded.value && resolvedComp) { 11661 return createInnerComp(resolvedComp, instance); 11662 } else if (error.value && errorComponent) { 11663 return createVNode(errorComponent, { 11664 error: error.value 11665 }); 11666 } else if (loadingComponent && !delayed.value) { 11667 return createVNode(loadingComponent); 11668 } 11669 }; 11670 } 11671 }); 11672} 11673function createInnerComp(comp, parent) { 11674 const { ref: ref2, props, children, ce } = parent.vnode; 11675 const vnode = createVNode(comp, props, children); 11676 vnode.ref = ref2; 11677 vnode.ce = ce; 11678 delete parent.vnode.ce; 11679 return vnode; 11680} 11681 11682const isKeepAlive = (vnode) => vnode.type.__isKeepAlive; 11683const KeepAliveImpl = { 11684 name: `KeepAlive`, 11685 // Marker for special handling inside the renderer. We are not using a === 11686 // check directly on KeepAlive in the renderer, because importing it directly 11687 // would prevent it from being tree-shaken. 11688 __isKeepAlive: true, 11689 props: { 11690 include: [String, RegExp, Array], 11691 exclude: [String, RegExp, Array], 11692 max: [String, Number] 11693 }, 11694 setup(props, { slots }) { 11695 const instance = getCurrentInstance(); 11696 const sharedContext = instance.ctx; 11697 if (!sharedContext.renderer) { 11698 return () => { 11699 const children = slots.default && slots.default(); 11700 return children && children.length === 1 ? children[0] : children; 11701 }; 11702 } 11703 const cache = /* @__PURE__ */ new Map(); 11704 const keys = /* @__PURE__ */ new Set(); 11705 let current = null; 11706 if (true) { 11707 instance.__v_cache = cache; 11708 } 11709 const parentSuspense = instance.suspense; 11710 const { 11711 renderer: { 11712 p: patch, 11713 m: move, 11714 um: _unmount, 11715 o: { createElement } 11716 } 11717 } = sharedContext; 11718 const storageContainer = createElement("div"); 11719 sharedContext.activate = (vnode, container, anchor, namespace, optimized) => { 11720 const instance2 = vnode.component; 11721 move(vnode, container, anchor, 0, parentSuspense); 11722 patch( 11723 instance2.vnode, 11724 vnode, 11725 container, 11726 anchor, 11727 instance2, 11728 parentSuspense, 11729 namespace, 11730 vnode.slotScopeIds, 11731 optimized 11732 ); 11733 queuePostRenderEffect(() => { 11734 instance2.isDeactivated = false; 11735 if (instance2.a) { 11736 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance2.a); 11737 } 11738 const vnodeHook = vnode.props && vnode.props.onVnodeMounted; 11739 if (vnodeHook) { 11740 invokeVNodeHook(vnodeHook, instance2.parent, vnode); 11741 } 11742 }, parentSuspense); 11743 if (true) { 11744 devtoolsComponentAdded(instance2); 11745 } 11746 }; 11747 sharedContext.deactivate = (vnode) => { 11748 const instance2 = vnode.component; 11749 invalidateMount(instance2.m); 11750 invalidateMount(instance2.a); 11751 move(vnode, storageContainer, null, 1, parentSuspense); 11752 queuePostRenderEffect(() => { 11753 if (instance2.da) { 11754 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance2.da); 11755 } 11756 const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted; 11757 if (vnodeHook) { 11758 invokeVNodeHook(vnodeHook, instance2.parent, vnode); 11759 } 11760 instance2.isDeactivated = true; 11761 }, parentSuspense); 11762 if (true) { 11763 devtoolsComponentAdded(instance2); 11764 } 11765 }; 11766 function unmount(vnode) { 11767 resetShapeFlag(vnode); 11768 _unmount(vnode, instance, parentSuspense, true); 11769 } 11770 function pruneCache(filter) { 11771 cache.forEach((vnode, key) => { 11772 const name = getComponentName(vnode.type); 11773 if (name && !filter(name)) { 11774 pruneCacheEntry(key); 11775 } 11776 }); 11777 } 11778 function pruneCacheEntry(key) { 11779 const cached = cache.get(key); 11780 if (cached && (!current || !isSameVNodeType(cached, current))) { 11781 unmount(cached); 11782 } else if (current) { 11783 resetShapeFlag(current); 11784 } 11785 cache.delete(key); 11786 keys.delete(key); 11787 } 11788 watch( 11789 () => [props.include, props.exclude], 11790 ([include, exclude]) => { 11791 include && pruneCache((name) => matches(include, name)); 11792 exclude && pruneCache((name) => !matches(exclude, name)); 11793 }, 11794 // prune post-render after `current` has been updated 11795 { flush: "post", deep: true } 11796 ); 11797 let pendingCacheKey = null; 11798 const cacheSubtree = () => { 11799 if (pendingCacheKey != null) { 11800 if (isSuspense(instance.subTree.type)) { 11801 queuePostRenderEffect(() => { 11802 cache.set(pendingCacheKey, getInnerChild(instance.subTree)); 11803 }, instance.subTree.suspense); 11804 } else { 11805 cache.set(pendingCacheKey, getInnerChild(instance.subTree)); 11806 } 11807 } 11808 }; 11809 onMounted(cacheSubtree); 11810 onUpdated(cacheSubtree); 11811 onBeforeUnmount(() => { 11812 cache.forEach((cached) => { 11813 const { subTree, suspense } = instance; 11814 const vnode = getInnerChild(subTree); 11815 if (cached.type === vnode.type && cached.key === vnode.key) { 11816 resetShapeFlag(vnode); 11817 const da = vnode.component.da; 11818 da && queuePostRenderEffect(da, suspense); 11819 return; 11820 } 11821 unmount(cached); 11822 }); 11823 }); 11824 return () => { 11825 pendingCacheKey = null; 11826 if (!slots.default) { 11827 return current = null; 11828 } 11829 const children = slots.default(); 11830 const rawVNode = children[0]; 11831 if (children.length > 1) { 11832 if (true) { 11833 warn$1(`KeepAlive should contain exactly one component child.`); 11834 } 11835 current = null; 11836 return children; 11837 } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) { 11838 current = null; 11839 return rawVNode; 11840 } 11841 let vnode = getInnerChild(rawVNode); 11842 if (vnode.type === Comment) { 11843 current = null; 11844 return vnode; 11845 } 11846 const comp = vnode.type; 11847 const name = getComponentName( 11848 isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp 11849 ); 11850 const { include, exclude, max } = props; 11851 if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) { 11852 vnode.shapeFlag &= ~256; 11853 current = vnode; 11854 return rawVNode; 11855 } 11856 const key = vnode.key == null ? comp : vnode.key; 11857 const cachedVNode = cache.get(key); 11858 if (vnode.el) { 11859 vnode = cloneVNode(vnode); 11860 if (rawVNode.shapeFlag & 128) { 11861 rawVNode.ssContent = vnode; 11862 } 11863 } 11864 pendingCacheKey = key; 11865 if (cachedVNode) { 11866 vnode.el = cachedVNode.el; 11867 vnode.component = cachedVNode.component; 11868 if (vnode.transition) { 11869 setTransitionHooks(vnode, vnode.transition); 11870 } 11871 vnode.shapeFlag |= 512; 11872 keys.delete(key); 11873 keys.add(key); 11874 } else { 11875 keys.add(key); 11876 if (max && keys.size > parseInt(max, 10)) { 11877 pruneCacheEntry(keys.values().next().value); 11878 } 11879 } 11880 vnode.shapeFlag |= 256; 11881 current = vnode; 11882 return isSuspense(rawVNode.type) ? rawVNode : vnode; 11883 }; 11884 } 11885}; 11886const KeepAlive = KeepAliveImpl; 11887function matches(pattern, name) { 11888 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(pattern)) { 11889 return pattern.some((p) => matches(p, name)); 11890 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(pattern)) { 11891 return pattern.split(",").includes(name); 11892 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isRegExp)(pattern)) { 11893 pattern.lastIndex = 0; 11894 return pattern.test(name); 11895 } 11896 return false; 11897} 11898function onActivated(hook, target) { 11899 registerKeepAliveHook(hook, "a", target); 11900} 11901function onDeactivated(hook, target) { 11902 registerKeepAliveHook(hook, "da", target); 11903} 11904function registerKeepAliveHook(hook, type, target = currentInstance) { 11905 const wrappedHook = hook.__wdc || (hook.__wdc = () => { 11906 let current = target; 11907 while (current) { 11908 if (current.isDeactivated) { 11909 return; 11910 } 11911 current = current.parent; 11912 } 11913 return hook(); 11914 }); 11915 injectHook(type, wrappedHook, target); 11916 if (target) { 11917 let current = target.parent; 11918 while (current && current.parent) { 11919 if (isKeepAlive(current.parent.vnode)) { 11920 injectToKeepAliveRoot(wrappedHook, type, target, current); 11921 } 11922 current = current.parent; 11923 } 11924 } 11925} 11926function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { 11927 const injected = injectHook( 11928 type, 11929 hook, 11930 keepAliveRoot, 11931 true 11932 /* prepend */ 11933 ); 11934 onUnmounted(() => { 11935 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.remove)(keepAliveRoot[type], injected); 11936 }, target); 11937} 11938function resetShapeFlag(vnode) { 11939 vnode.shapeFlag &= ~256; 11940 vnode.shapeFlag &= ~512; 11941} 11942function getInnerChild(vnode) { 11943 return vnode.shapeFlag & 128 ? vnode.ssContent : vnode; 11944} 11945 11946function injectHook(type, hook, target = currentInstance, prepend = false) { 11947 if (target) { 11948 const hooks = target[type] || (target[type] = []); 11949 const wrappedHook = hook.__weh || (hook.__weh = (...args) => { 11950 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 11951 const reset = setCurrentInstance(target); 11952 const res = callWithAsyncErrorHandling(hook, target, type, args); 11953 reset(); 11954 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 11955 return res; 11956 }); 11957 if (prepend) { 11958 hooks.unshift(wrappedHook); 11959 } else { 11960 hooks.push(wrappedHook); 11961 } 11962 return wrappedHook; 11963 } else if (true) { 11964 const apiName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(ErrorTypeStrings$1[type].replace(/ hook$/, "")); 11965 warn$1( 11966 `${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().` + (` If you are using async setup(), make sure to register lifecycle hooks before the first await statement.` ) 11967 ); 11968 } 11969} 11970const createHook = (lifecycle) => (hook, target = currentInstance) => { 11971 if (!isInSSRComponentSetup || lifecycle === "sp") { 11972 injectHook(lifecycle, (...args) => hook(...args), target); 11973 } 11974}; 11975const onBeforeMount = createHook("bm"); 11976const onMounted = createHook("m"); 11977const onBeforeUpdate = createHook( 11978 "bu" 11979); 11980const onUpdated = createHook("u"); 11981const onBeforeUnmount = createHook( 11982 "bum" 11983); 11984const onUnmounted = createHook("um"); 11985const onServerPrefetch = createHook( 11986 "sp" 11987); 11988const onRenderTriggered = createHook("rtg"); 11989const onRenderTracked = createHook("rtc"); 11990function onErrorCaptured(hook, target = currentInstance) { 11991 injectHook("ec", hook, target); 11992} 11993 11994const COMPONENTS = "components"; 11995const DIRECTIVES = "directives"; 11996function resolveComponent(name, maybeSelfReference) { 11997 return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name; 11998} 11999const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc"); 12000function resolveDynamicComponent(component) { 12001 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(component)) { 12002 return resolveAsset(COMPONENTS, component, false) || component; 12003 } else { 12004 return component || NULL_DYNAMIC_COMPONENT; 12005 } 12006} 12007function resolveDirective(name) { 12008 return resolveAsset(DIRECTIVES, name); 12009} 12010function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) { 12011 const instance = currentRenderingInstance || currentInstance; 12012 if (instance) { 12013 const Component = instance.type; 12014 if (type === COMPONENTS) { 12015 const selfName = getComponentName( 12016 Component, 12017 false 12018 ); 12019 if (selfName && (selfName === name || selfName === (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name) || selfName === (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name)))) { 12020 return Component; 12021 } 12022 } 12023 const res = ( 12024 // local registration 12025 // check instance[type] first which is resolved for options API 12026 resolve(instance[type] || Component[type], name) || // global registration 12027 resolve(instance.appContext[type], name) 12028 ); 12029 if (!res && maybeSelfReference) { 12030 return Component; 12031 } 12032 if ( true && warnMissing && !res) { 12033 const extra = type === COMPONENTS ? ` 12034If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``; 12035 warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`); 12036 } 12037 return res; 12038 } else if (true) { 12039 warn$1( 12040 `resolve${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)(type.slice(0, -1))} can only be used in render() or setup().` 12041 ); 12042 } 12043} 12044function resolve(registry, name) { 12045 return registry && (registry[name] || registry[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name)] || registry[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name))]); 12046} 12047 12048function renderList(source, renderItem, cache, index) { 12049 let ret; 12050 const cached = cache && cache[index]; 12051 const sourceIsArray = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(source); 12052 if (sourceIsArray || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(source)) { 12053 const sourceIsReactiveArray = sourceIsArray && (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive)(source); 12054 let needsWrap = false; 12055 if (sourceIsReactiveArray) { 12056 needsWrap = !(0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(source); 12057 source = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadArray)(source); 12058 } 12059 ret = new Array(source.length); 12060 for (let i = 0, l = source.length; i < l; i++) { 12061 ret[i] = renderItem( 12062 needsWrap ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toReactive)(source[i]) : source[i], 12063 i, 12064 void 0, 12065 cached && cached[i] 12066 ); 12067 } 12068 } else if (typeof source === "number") { 12069 if ( true && !Number.isInteger(source)) { 12070 warn$1(`The v-for range expect an integer value but got ${source}.`); 12071 } 12072 ret = new Array(source); 12073 for (let i = 0; i < source; i++) { 12074 ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]); 12075 } 12076 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(source)) { 12077 if (source[Symbol.iterator]) { 12078 ret = Array.from( 12079 source, 12080 (item, i) => renderItem(item, i, void 0, cached && cached[i]) 12081 ); 12082 } else { 12083 const keys = Object.keys(source); 12084 ret = new Array(keys.length); 12085 for (let i = 0, l = keys.length; i < l; i++) { 12086 const key = keys[i]; 12087 ret[i] = renderItem(source[key], key, i, cached && cached[i]); 12088 } 12089 } 12090 } else { 12091 ret = []; 12092 } 12093 if (cache) { 12094 cache[index] = ret; 12095 } 12096 return ret; 12097} 12098 12099function createSlots(slots, dynamicSlots) { 12100 for (let i = 0; i < dynamicSlots.length; i++) { 12101 const slot = dynamicSlots[i]; 12102 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(slot)) { 12103 for (let j = 0; j < slot.length; j++) { 12104 slots[slot[j].name] = slot[j].fn; 12105 } 12106 } else if (slot) { 12107 slots[slot.name] = slot.key ? (...args) => { 12108 const res = slot.fn(...args); 12109 if (res) res.key = slot.key; 12110 return res; 12111 } : slot.fn; 12112 } 12113 } 12114 return slots; 12115} 12116 12117function renderSlot(slots, name, props = {}, fallback, noSlotted) { 12118 if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) { 12119 if (name !== "default") props.name = name; 12120 return openBlock(), createBlock( 12121 Fragment, 12122 null, 12123 [createVNode("slot", props, fallback && fallback())], 12124 64 12125 ); 12126 } 12127 let slot = slots[name]; 12128 if ( true && slot && slot.length > 1) { 12129 warn$1( 12130 `SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.` 12131 ); 12132 slot = () => []; 12133 } 12134 if (slot && slot._c) { 12135 slot._d = false; 12136 } 12137 openBlock(); 12138 const validSlotContent = slot && ensureValidVNode(slot(props)); 12139 const slotKey = props.key || // slot content array of a dynamic conditional slot may have a branch 12140 // key attached in the `createSlots` helper, respect that 12141 validSlotContent && validSlotContent.key; 12142 const rendered = createBlock( 12143 Fragment, 12144 { 12145 key: (slotKey && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSymbol)(slotKey) ? slotKey : `_${name}`) + // #7256 force differentiate fallback content from actual content 12146 (!validSlotContent && fallback ? "_fb" : "") 12147 }, 12148 validSlotContent || (fallback ? fallback() : []), 12149 validSlotContent && slots._ === 1 ? 64 : -2 12150 ); 12151 if (!noSlotted && rendered.scopeId) { 12152 rendered.slotScopeIds = [rendered.scopeId + "-s"]; 12153 } 12154 if (slot && slot._c) { 12155 slot._d = true; 12156 } 12157 return rendered; 12158} 12159function ensureValidVNode(vnodes) { 12160 return vnodes.some((child) => { 12161 if (!isVNode(child)) return true; 12162 if (child.type === Comment) return false; 12163 if (child.type === Fragment && !ensureValidVNode(child.children)) 12164 return false; 12165 return true; 12166 }) ? vnodes : null; 12167} 12168 12169function toHandlers(obj, preserveCaseIfNecessary) { 12170 const ret = {}; 12171 if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(obj)) { 12172 warn$1(`v-on with no argument expects an object value.`); 12173 return ret; 12174 } 12175 for (const key in obj) { 12176 ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(key)] = obj[key]; 12177 } 12178 return ret; 12179} 12180 12181const getPublicInstance = (i) => { 12182 if (!i) return null; 12183 if (isStatefulComponent(i)) return getComponentPublicInstance(i); 12184 return getPublicInstance(i.parent); 12185}; 12186const publicPropertiesMap = ( 12187 // Move PURE marker to new line to workaround compiler discarding it 12188 // due to type annotation 12189 /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(/* @__PURE__ */ Object.create(null), { 12190 $: (i) => i, 12191 $el: (i) => i.vnode.el, 12192 $data: (i) => i.data, 12193 $props: (i) => true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.props) : 0, 12194 $attrs: (i) => true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.attrs) : 0, 12195 $slots: (i) => true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.slots) : 0, 12196 $refs: (i) => true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.refs) : 0, 12197 $parent: (i) => getPublicInstance(i.parent), 12198 $root: (i) => getPublicInstance(i.root), 12199 $host: (i) => i.ce, 12200 $emit: (i) => i.emit, 12201 $options: (i) => true ? resolveMergedOptions(i) : 0, 12202 $forceUpdate: (i) => i.f || (i.f = () => { 12203 queueJob(i.update); 12204 }), 12205 $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)), 12206 $watch: (i) => true ? instanceWatch.bind(i) : 0 12207 }) 12208); 12209const isReservedPrefix = (key) => key === "_" || key === "$"; 12210const hasSetupBinding = (state, key) => state !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && !state.__isScriptSetup && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(state, key); 12211const PublicInstanceProxyHandlers = { 12212 get({ _: instance }, key) { 12213 if (key === "__v_skip") { 12214 return true; 12215 } 12216 const { ctx, setupState, data, props, accessCache, type, appContext } = instance; 12217 if ( true && key === "__isVue") { 12218 return true; 12219 } 12220 let normalizedProps; 12221 if (key[0] !== "$") { 12222 const n = accessCache[key]; 12223 if (n !== void 0) { 12224 switch (n) { 12225 case 1 /* SETUP */: 12226 return setupState[key]; 12227 case 2 /* DATA */: 12228 return data[key]; 12229 case 4 /* CONTEXT */: 12230 return ctx[key]; 12231 case 3 /* PROPS */: 12232 return props[key]; 12233 } 12234 } else if (hasSetupBinding(setupState, key)) { 12235 accessCache[key] = 1 /* SETUP */; 12236 return setupState[key]; 12237 } else if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key)) { 12238 accessCache[key] = 2 /* DATA */; 12239 return data[key]; 12240 } else if ( 12241 // only cache other properties when instance has declared (thus stable) 12242 // props 12243 (normalizedProps = instance.propsOptions[0]) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(normalizedProps, key) 12244 ) { 12245 accessCache[key] = 3 /* PROPS */; 12246 return props[key]; 12247 } else if (ctx !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(ctx, key)) { 12248 accessCache[key] = 4 /* CONTEXT */; 12249 return ctx[key]; 12250 } else if ( false || shouldCacheAccess) { 12251 accessCache[key] = 0 /* OTHER */; 12252 } 12253 } 12254 const publicGetter = publicPropertiesMap[key]; 12255 let cssModule, globalProperties; 12256 if (publicGetter) { 12257 if (key === "$attrs") { 12258 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.track)(instance.attrs, "get", ""); 12259 true && markAttrsAccessed(); 12260 } else if ( true && key === "$slots") { 12261 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.track)(instance, "get", key); 12262 } 12263 return publicGetter(instance); 12264 } else if ( 12265 // css module (injected by vue-loader) 12266 (cssModule = type.__cssModules) && (cssModule = cssModule[key]) 12267 ) { 12268 return cssModule; 12269 } else if (ctx !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(ctx, key)) { 12270 accessCache[key] = 4 /* CONTEXT */; 12271 return ctx[key]; 12272 } else if ( 12273 // global properties 12274 globalProperties = appContext.config.globalProperties, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(globalProperties, key) 12275 ) { 12276 { 12277 return globalProperties[key]; 12278 } 12279 } else if ( true && currentRenderingInstance && (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading 12280 // to infinite warning loop 12281 key.indexOf("__v") !== 0)) { 12282 if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && isReservedPrefix(key[0]) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key)) { 12283 warn$1( 12284 `Property ${JSON.stringify( 12285 key 12286 )} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.` 12287 ); 12288 } else if (instance === currentRenderingInstance) { 12289 warn$1( 12290 `Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.` 12291 ); 12292 } 12293 } 12294 }, 12295 set({ _: instance }, key, value) { 12296 const { data, setupState, ctx } = instance; 12297 if (hasSetupBinding(setupState, key)) { 12298 setupState[key] = value; 12299 return true; 12300 } else if ( true && setupState.__isScriptSetup && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, key)) { 12301 warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`); 12302 return false; 12303 } else if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key)) { 12304 data[key] = value; 12305 return true; 12306 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(instance.props, key)) { 12307 true && warn$1(`Attempting to mutate prop "${key}". Props are readonly.`); 12308 return false; 12309 } 12310 if (key[0] === "$" && key.slice(1) in instance) { 12311 true && warn$1( 12312 `Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.` 12313 ); 12314 return false; 12315 } else { 12316 if ( true && key in instance.appContext.config.globalProperties) { 12317 Object.defineProperty(ctx, key, { 12318 enumerable: true, 12319 configurable: true, 12320 value 12321 }); 12322 } else { 12323 ctx[key] = value; 12324 } 12325 } 12326 return true; 12327 }, 12328 has({ 12329 _: { data, setupState, accessCache, ctx, appContext, propsOptions } 12330 }, key) { 12331 let normalizedProps; 12332 return !!accessCache[key] || data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(normalizedProps, key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(ctx, key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(publicPropertiesMap, key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(appContext.config.globalProperties, key); 12333 }, 12334 defineProperty(target, key, descriptor) { 12335 if (descriptor.get != null) { 12336 target._.accessCache[key] = 0; 12337 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(descriptor, "value")) { 12338 this.set(target, key, descriptor.value, null); 12339 } 12340 return Reflect.defineProperty(target, key, descriptor); 12341 } 12342}; 12343if (true) { 12344 PublicInstanceProxyHandlers.ownKeys = (target) => { 12345 warn$1( 12346 `Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.` 12347 ); 12348 return Reflect.ownKeys(target); 12349 }; 12350} 12351const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, PublicInstanceProxyHandlers, { 12352 get(target, key) { 12353 if (key === Symbol.unscopables) { 12354 return; 12355 } 12356 return PublicInstanceProxyHandlers.get(target, key, target); 12357 }, 12358 has(_, key) { 12359 const has = key[0] !== "_" && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isGloballyAllowed)(key); 12360 if ( true && !has && PublicInstanceProxyHandlers.has(_, key)) { 12361 warn$1( 12362 `Property ${JSON.stringify( 12363 key 12364 )} should not start with _ which is a reserved prefix for Vue internals.` 12365 ); 12366 } 12367 return has; 12368 } 12369}); 12370function createDevRenderContext(instance) { 12371 const target = {}; 12372 Object.defineProperty(target, `_`, { 12373 configurable: true, 12374 enumerable: false, 12375 get: () => instance 12376 }); 12377 Object.keys(publicPropertiesMap).forEach((key) => { 12378 Object.defineProperty(target, key, { 12379 configurable: true, 12380 enumerable: false, 12381 get: () => publicPropertiesMap[key](instance), 12382 // intercepted by the proxy so no need for implementation, 12383 // but needed to prevent set errors 12384 set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP 12385 }); 12386 }); 12387 return target; 12388} 12389function exposePropsOnRenderContext(instance) { 12390 const { 12391 ctx, 12392 propsOptions: [propsOptions] 12393 } = instance; 12394 if (propsOptions) { 12395 Object.keys(propsOptions).forEach((key) => { 12396 Object.defineProperty(ctx, key, { 12397 enumerable: true, 12398 configurable: true, 12399 get: () => instance.props[key], 12400 set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP 12401 }); 12402 }); 12403 } 12404} 12405function exposeSetupStateOnRenderContext(instance) { 12406 const { ctx, setupState } = instance; 12407 Object.keys((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(setupState)).forEach((key) => { 12408 if (!setupState.__isScriptSetup) { 12409 if (isReservedPrefix(key[0])) { 12410 warn$1( 12411 `setup() return property ${JSON.stringify( 12412 key 12413 )} should not start with "$" or "_" which are reserved prefixes for Vue internals.` 12414 ); 12415 return; 12416 } 12417 Object.defineProperty(ctx, key, { 12418 enumerable: true, 12419 configurable: true, 12420 get: () => setupState[key], 12421 set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP 12422 }); 12423 } 12424 }); 12425} 12426 12427const warnRuntimeUsage = (method) => warn$1( 12428 `${method}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.` 12429); 12430function defineProps() { 12431 if (true) { 12432 warnRuntimeUsage(`defineProps`); 12433 } 12434 return null; 12435} 12436function defineEmits() { 12437 if (true) { 12438 warnRuntimeUsage(`defineEmits`); 12439 } 12440 return null; 12441} 12442function defineExpose(exposed) { 12443 if (true) { 12444 warnRuntimeUsage(`defineExpose`); 12445 } 12446} 12447function defineOptions(options) { 12448 if (true) { 12449 warnRuntimeUsage(`defineOptions`); 12450 } 12451} 12452function defineSlots() { 12453 if (true) { 12454 warnRuntimeUsage(`defineSlots`); 12455 } 12456 return null; 12457} 12458function defineModel() { 12459 if (true) { 12460 warnRuntimeUsage("defineModel"); 12461 } 12462} 12463function withDefaults(props, defaults) { 12464 if (true) { 12465 warnRuntimeUsage(`withDefaults`); 12466 } 12467 return null; 12468} 12469function useSlots() { 12470 return getContext().slots; 12471} 12472function useAttrs() { 12473 return getContext().attrs; 12474} 12475function getContext() { 12476 const i = getCurrentInstance(); 12477 if ( true && !i) { 12478 warn$1(`useContext() called without active instance.`); 12479 } 12480 return i.setupContext || (i.setupContext = createSetupContext(i)); 12481} 12482function normalizePropsOrEmits(props) { 12483 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(props) ? props.reduce( 12484 (normalized, p) => (normalized[p] = null, normalized), 12485 {} 12486 ) : props; 12487} 12488function mergeDefaults(raw, defaults) { 12489 const props = normalizePropsOrEmits(raw); 12490 for (const key in defaults) { 12491 if (key.startsWith("__skip")) continue; 12492 let opt = props[key]; 12493 if (opt) { 12494 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(opt) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt)) { 12495 opt = props[key] = { type: opt, default: defaults[key] }; 12496 } else { 12497 opt.default = defaults[key]; 12498 } 12499 } else if (opt === null) { 12500 opt = props[key] = { default: defaults[key] }; 12501 } else if (true) { 12502 warn$1(`props default key "${key}" has no corresponding declaration.`); 12503 } 12504 if (opt && defaults[`__skip_${key}`]) { 12505 opt.skipFactory = true; 12506 } 12507 } 12508 return props; 12509} 12510function mergeModels(a, b) { 12511 if (!a || !b) return a || b; 12512 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(a) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(b)) return a.concat(b); 12513 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b)); 12514} 12515function createPropsRestProxy(props, excludedKeys) { 12516 const ret = {}; 12517 for (const key in props) { 12518 if (!excludedKeys.includes(key)) { 12519 Object.defineProperty(ret, key, { 12520 enumerable: true, 12521 get: () => props[key] 12522 }); 12523 } 12524 } 12525 return ret; 12526} 12527function withAsyncContext(getAwaitable) { 12528 const ctx = getCurrentInstance(); 12529 if ( true && !ctx) { 12530 warn$1( 12531 `withAsyncContext called without active current instance. This is likely a bug.` 12532 ); 12533 } 12534 let awaitable = getAwaitable(); 12535 unsetCurrentInstance(); 12536 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(awaitable)) { 12537 awaitable = awaitable.catch((e) => { 12538 setCurrentInstance(ctx); 12539 throw e; 12540 }); 12541 } 12542 return [awaitable, () => setCurrentInstance(ctx)]; 12543} 12544 12545function createDuplicateChecker() { 12546 const cache = /* @__PURE__ */ Object.create(null); 12547 return (type, key) => { 12548 if (cache[key]) { 12549 warn$1(`${type} property "${key}" is already defined in ${cache[key]}.`); 12550 } else { 12551 cache[key] = type; 12552 } 12553 }; 12554} 12555let shouldCacheAccess = true; 12556function applyOptions(instance) { 12557 const options = resolveMergedOptions(instance); 12558 const publicThis = instance.proxy; 12559 const ctx = instance.ctx; 12560 shouldCacheAccess = false; 12561 if (options.beforeCreate) { 12562 callHook(options.beforeCreate, instance, "bc"); 12563 } 12564 const { 12565 // state 12566 data: dataOptions, 12567 computed: computedOptions, 12568 methods, 12569 watch: watchOptions, 12570 provide: provideOptions, 12571 inject: injectOptions, 12572 // lifecycle 12573 created, 12574 beforeMount, 12575 mounted, 12576 beforeUpdate, 12577 updated, 12578 activated, 12579 deactivated, 12580 beforeDestroy, 12581 beforeUnmount, 12582 destroyed, 12583 unmounted, 12584 render, 12585 renderTracked, 12586 renderTriggered, 12587 errorCaptured, 12588 serverPrefetch, 12589 // public API 12590 expose, 12591 inheritAttrs, 12592 // assets 12593 components, 12594 directives, 12595 filters 12596 } = options; 12597 const checkDuplicateProperties = true ? createDuplicateChecker() : 0; 12598 if (true) { 12599 const [propsOptions] = instance.propsOptions; 12600 if (propsOptions) { 12601 for (const key in propsOptions) { 12602 checkDuplicateProperties("Props" /* PROPS */, key); 12603 } 12604 } 12605 } 12606 if (injectOptions) { 12607 resolveInjections(injectOptions, ctx, checkDuplicateProperties); 12608 } 12609 if (methods) { 12610 for (const key in methods) { 12611 const methodHandler = methods[key]; 12612 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(methodHandler)) { 12613 if (true) { 12614 Object.defineProperty(ctx, key, { 12615 value: methodHandler.bind(publicThis), 12616 configurable: true, 12617 enumerable: true, 12618 writable: true 12619 }); 12620 } else {} 12621 if (true) { 12622 checkDuplicateProperties("Methods" /* METHODS */, key); 12623 } 12624 } else if (true) { 12625 warn$1( 12626 `Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?` 12627 ); 12628 } 12629 } 12630 } 12631 if (dataOptions) { 12632 if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(dataOptions)) { 12633 warn$1( 12634 `The data option must be a function. Plain object usage is no longer supported.` 12635 ); 12636 } 12637 const data = dataOptions.call(publicThis, publicThis); 12638 if ( true && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(data)) { 12639 warn$1( 12640 `data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.` 12641 ); 12642 } 12643 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(data)) { 12644 true && warn$1(`data() should return an object.`); 12645 } else { 12646 instance.data = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.reactive)(data); 12647 if (true) { 12648 for (const key in data) { 12649 checkDuplicateProperties("Data" /* DATA */, key); 12650 if (!isReservedPrefix(key[0])) { 12651 Object.defineProperty(ctx, key, { 12652 configurable: true, 12653 enumerable: true, 12654 get: () => data[key], 12655 set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP 12656 }); 12657 } 12658 } 12659 } 12660 } 12661 } 12662 shouldCacheAccess = true; 12663 if (computedOptions) { 12664 for (const key in computedOptions) { 12665 const opt = computedOptions[key]; 12666 const get = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt) ? opt.bind(publicThis, publicThis) : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt.get) ? opt.get.bind(publicThis, publicThis) : _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP; 12667 if ( true && get === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP) { 12668 warn$1(`Computed property "${key}" has no getter.`); 12669 } 12670 const set = !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt.set) ? opt.set.bind(publicThis) : true ? () => { 12671 warn$1( 12672 `Write operation failed: computed property "${key}" is readonly.` 12673 ); 12674 } : 0; 12675 const c = computed({ 12676 get, 12677 set 12678 }); 12679 Object.defineProperty(ctx, key, { 12680 enumerable: true, 12681 configurable: true, 12682 get: () => c.value, 12683 set: (v) => c.value = v 12684 }); 12685 if (true) { 12686 checkDuplicateProperties("Computed" /* COMPUTED */, key); 12687 } 12688 } 12689 } 12690 if (watchOptions) { 12691 for (const key in watchOptions) { 12692 createWatcher(watchOptions[key], ctx, publicThis, key); 12693 } 12694 } 12695 if (provideOptions) { 12696 const provides = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(provideOptions) ? provideOptions.call(publicThis) : provideOptions; 12697 Reflect.ownKeys(provides).forEach((key) => { 12698 provide(key, provides[key]); 12699 }); 12700 } 12701 if (created) { 12702 callHook(created, instance, "c"); 12703 } 12704 function registerLifecycleHook(register, hook) { 12705 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook)) { 12706 hook.forEach((_hook) => register(_hook.bind(publicThis))); 12707 } else if (hook) { 12708 register(hook.bind(publicThis)); 12709 } 12710 } 12711 registerLifecycleHook(onBeforeMount, beforeMount); 12712 registerLifecycleHook(onMounted, mounted); 12713 registerLifecycleHook(onBeforeUpdate, beforeUpdate); 12714 registerLifecycleHook(onUpdated, updated); 12715 registerLifecycleHook(onActivated, activated); 12716 registerLifecycleHook(onDeactivated, deactivated); 12717 registerLifecycleHook(onErrorCaptured, errorCaptured); 12718 registerLifecycleHook(onRenderTracked, renderTracked); 12719 registerLifecycleHook(onRenderTriggered, renderTriggered); 12720 registerLifecycleHook(onBeforeUnmount, beforeUnmount); 12721 registerLifecycleHook(onUnmounted, unmounted); 12722 registerLifecycleHook(onServerPrefetch, serverPrefetch); 12723 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(expose)) { 12724 if (expose.length) { 12725 const exposed = instance.exposed || (instance.exposed = {}); 12726 expose.forEach((key) => { 12727 Object.defineProperty(exposed, key, { 12728 get: () => publicThis[key], 12729 set: (val) => publicThis[key] = val 12730 }); 12731 }); 12732 } else if (!instance.exposed) { 12733 instance.exposed = {}; 12734 } 12735 } 12736 if (render && instance.render === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP) { 12737 instance.render = render; 12738 } 12739 if (inheritAttrs != null) { 12740 instance.inheritAttrs = inheritAttrs; 12741 } 12742 if (components) instance.components = components; 12743 if (directives) instance.directives = directives; 12744 if (serverPrefetch) { 12745 markAsyncBoundary(instance); 12746 } 12747} 12748function resolveInjections(injectOptions, ctx, checkDuplicateProperties = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP) { 12749 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(injectOptions)) { 12750 injectOptions = normalizeInject(injectOptions); 12751 } 12752 for (const key in injectOptions) { 12753 const opt = injectOptions[key]; 12754 let injected; 12755 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(opt)) { 12756 if ("default" in opt) { 12757 injected = inject( 12758 opt.from || key, 12759 opt.default, 12760 true 12761 ); 12762 } else { 12763 injected = inject(opt.from || key); 12764 } 12765 } else { 12766 injected = inject(opt); 12767 } 12768 if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(injected)) { 12769 Object.defineProperty(ctx, key, { 12770 enumerable: true, 12771 configurable: true, 12772 get: () => injected.value, 12773 set: (v) => injected.value = v 12774 }); 12775 } else { 12776 ctx[key] = injected; 12777 } 12778 if (true) { 12779 checkDuplicateProperties("Inject" /* INJECT */, key); 12780 } 12781 } 12782} 12783function callHook(hook, instance, type) { 12784 callWithAsyncErrorHandling( 12785 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy), 12786 instance, 12787 type 12788 ); 12789} 12790function createWatcher(raw, ctx, publicThis, key) { 12791 let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key]; 12792 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(raw)) { 12793 const handler = ctx[raw]; 12794 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(handler)) { 12795 { 12796 watch(getter, handler); 12797 } 12798 } else if (true) { 12799 warn$1(`Invalid watch handler specified by key "${raw}"`, handler); 12800 } 12801 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(raw)) { 12802 { 12803 watch(getter, raw.bind(publicThis)); 12804 } 12805 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(raw)) { 12806 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) { 12807 raw.forEach((r) => createWatcher(r, ctx, publicThis, key)); 12808 } else { 12809 const handler = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler]; 12810 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(handler)) { 12811 watch(getter, handler, raw); 12812 } else if (true) { 12813 warn$1(`Invalid watch handler specified by key "${raw.handler}"`, handler); 12814 } 12815 } 12816 } else if (true) { 12817 warn$1(`Invalid watch option: "${key}"`, raw); 12818 } 12819} 12820function resolveMergedOptions(instance) { 12821 const base = instance.type; 12822 const { mixins, extends: extendsOptions } = base; 12823 const { 12824 mixins: globalMixins, 12825 optionsCache: cache, 12826 config: { optionMergeStrategies } 12827 } = instance.appContext; 12828 const cached = cache.get(base); 12829 let resolved; 12830 if (cached) { 12831 resolved = cached; 12832 } else if (!globalMixins.length && !mixins && !extendsOptions) { 12833 { 12834 resolved = base; 12835 } 12836 } else { 12837 resolved = {}; 12838 if (globalMixins.length) { 12839 globalMixins.forEach( 12840 (m) => mergeOptions(resolved, m, optionMergeStrategies, true) 12841 ); 12842 } 12843 mergeOptions(resolved, base, optionMergeStrategies); 12844 } 12845 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(base)) { 12846 cache.set(base, resolved); 12847 } 12848 return resolved; 12849} 12850function mergeOptions(to, from, strats, asMixin = false) { 12851 const { mixins, extends: extendsOptions } = from; 12852 if (extendsOptions) { 12853 mergeOptions(to, extendsOptions, strats, true); 12854 } 12855 if (mixins) { 12856 mixins.forEach( 12857 (m) => mergeOptions(to, m, strats, true) 12858 ); 12859 } 12860 for (const key in from) { 12861 if (asMixin && key === "expose") { 12862 true && warn$1( 12863 `"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.` 12864 ); 12865 } else { 12866 const strat = internalOptionMergeStrats[key] || strats && strats[key]; 12867 to[key] = strat ? strat(to[key], from[key]) : from[key]; 12868 } 12869 } 12870 return to; 12871} 12872const internalOptionMergeStrats = { 12873 data: mergeDataFn, 12874 props: mergeEmitsOrPropsOptions, 12875 emits: mergeEmitsOrPropsOptions, 12876 // objects 12877 methods: mergeObjectOptions, 12878 computed: mergeObjectOptions, 12879 // lifecycle 12880 beforeCreate: mergeAsArray, 12881 created: mergeAsArray, 12882 beforeMount: mergeAsArray, 12883 mounted: mergeAsArray, 12884 beforeUpdate: mergeAsArray, 12885 updated: mergeAsArray, 12886 beforeDestroy: mergeAsArray, 12887 beforeUnmount: mergeAsArray, 12888 destroyed: mergeAsArray, 12889 unmounted: mergeAsArray, 12890 activated: mergeAsArray, 12891 deactivated: mergeAsArray, 12892 errorCaptured: mergeAsArray, 12893 serverPrefetch: mergeAsArray, 12894 // assets 12895 components: mergeObjectOptions, 12896 directives: mergeObjectOptions, 12897 // watch 12898 watch: mergeWatchOptions, 12899 // provide / inject 12900 provide: mergeDataFn, 12901 inject: mergeInject 12902}; 12903function mergeDataFn(to, from) { 12904 if (!from) { 12905 return to; 12906 } 12907 if (!to) { 12908 return from; 12909 } 12910 return function mergedDataFn() { 12911 return ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend))( 12912 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(to) ? to.call(this, this) : to, 12913 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(from) ? from.call(this, this) : from 12914 ); 12915 }; 12916} 12917function mergeInject(to, from) { 12918 return mergeObjectOptions(normalizeInject(to), normalizeInject(from)); 12919} 12920function normalizeInject(raw) { 12921 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) { 12922 const res = {}; 12923 for (let i = 0; i < raw.length; i++) { 12924 res[raw[i]] = raw[i]; 12925 } 12926 return res; 12927 } 12928 return raw; 12929} 12930function mergeAsArray(to, from) { 12931 return to ? [...new Set([].concat(to, from))] : from; 12932} 12933function mergeObjectOptions(to, from) { 12934 return to ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(/* @__PURE__ */ Object.create(null), to, from) : from; 12935} 12936function mergeEmitsOrPropsOptions(to, from) { 12937 if (to) { 12938 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(to) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(from)) { 12939 return [.../* @__PURE__ */ new Set([...to, ...from])]; 12940 } 12941 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)( 12942 /* @__PURE__ */ Object.create(null), 12943 normalizePropsOrEmits(to), 12944 normalizePropsOrEmits(from != null ? from : {}) 12945 ); 12946 } else { 12947 return from; 12948 } 12949} 12950function mergeWatchOptions(to, from) { 12951 if (!to) return from; 12952 if (!from) return to; 12953 const merged = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(/* @__PURE__ */ Object.create(null), to); 12954 for (const key in from) { 12955 merged[key] = mergeAsArray(to[key], from[key]); 12956 } 12957 return merged; 12958} 12959 12960function createAppContext() { 12961 return { 12962 app: null, 12963 config: { 12964 isNativeTag: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NO, 12965 performance: false, 12966 globalProperties: {}, 12967 optionMergeStrategies: {}, 12968 errorHandler: void 0, 12969 warnHandler: void 0, 12970 compilerOptions: {} 12971 }, 12972 mixins: [], 12973 components: {}, 12974 directives: {}, 12975 provides: /* @__PURE__ */ Object.create(null), 12976 optionsCache: /* @__PURE__ */ new WeakMap(), 12977 propsCache: /* @__PURE__ */ new WeakMap(), 12978 emitsCache: /* @__PURE__ */ new WeakMap() 12979 }; 12980} 12981let uid$1 = 0; 12982function createAppAPI(render, hydrate) { 12983 return function createApp(rootComponent, rootProps = null) { 12984 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(rootComponent)) { 12985 rootComponent = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, rootComponent); 12986 } 12987 if (rootProps != null && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(rootProps)) { 12988 true && warn$1(`root props passed to app.mount() must be an object.`); 12989 rootProps = null; 12990 } 12991 const context = createAppContext(); 12992 const installedPlugins = /* @__PURE__ */ new WeakSet(); 12993 const pluginCleanupFns = []; 12994 let isMounted = false; 12995 const app = context.app = { 12996 _uid: uid$1++, 12997 _component: rootComponent, 12998 _props: rootProps, 12999 _container: null, 13000 _context: context, 13001 _instance: null, 13002 version, 13003 get config() { 13004 return context.config; 13005 }, 13006 set config(v) { 13007 if (true) { 13008 warn$1( 13009 `app.config cannot be replaced. Modify individual options instead.` 13010 ); 13011 } 13012 }, 13013 use(plugin, ...options) { 13014 if (installedPlugins.has(plugin)) { 13015 true && warn$1(`Plugin has already been applied to target app.`); 13016 } else if (plugin && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(plugin.install)) { 13017 installedPlugins.add(plugin); 13018 plugin.install(app, ...options); 13019 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(plugin)) { 13020 installedPlugins.add(plugin); 13021 plugin(app, ...options); 13022 } else if (true) { 13023 warn$1( 13024 `A plugin must either be a function or an object with an "install" function.` 13025 ); 13026 } 13027 return app; 13028 }, 13029 mixin(mixin) { 13030 if (true) { 13031 if (!context.mixins.includes(mixin)) { 13032 context.mixins.push(mixin); 13033 } else if (true) { 13034 warn$1( 13035 "Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "") 13036 ); 13037 } 13038 } else {} 13039 return app; 13040 }, 13041 component(name, component) { 13042 if (true) { 13043 validateComponentName(name, context.config); 13044 } 13045 if (!component) { 13046 return context.components[name]; 13047 } 13048 if ( true && context.components[name]) { 13049 warn$1(`Component "${name}" has already been registered in target app.`); 13050 } 13051 context.components[name] = component; 13052 return app; 13053 }, 13054 directive(name, directive) { 13055 if (true) { 13056 validateDirectiveName(name); 13057 } 13058 if (!directive) { 13059 return context.directives[name]; 13060 } 13061 if ( true && context.directives[name]) { 13062 warn$1(`Directive "${name}" has already been registered in target app.`); 13063 } 13064 context.directives[name] = directive; 13065 return app; 13066 }, 13067 mount(rootContainer, isHydrate, namespace) { 13068 if (!isMounted) { 13069 if ( true && rootContainer.__vue_app__) { 13070 warn$1( 13071 `There is already an app instance mounted on the host container. 13072 If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.` 13073 ); 13074 } 13075 const vnode = app._ceVNode || createVNode(rootComponent, rootProps); 13076 vnode.appContext = context; 13077 if (namespace === true) { 13078 namespace = "svg"; 13079 } else if (namespace === false) { 13080 namespace = void 0; 13081 } 13082 if (true) { 13083 context.reload = () => { 13084 render( 13085 cloneVNode(vnode), 13086 rootContainer, 13087 namespace 13088 ); 13089 }; 13090 } 13091 if (isHydrate && hydrate) { 13092 hydrate(vnode, rootContainer); 13093 } else { 13094 render(vnode, rootContainer, namespace); 13095 } 13096 isMounted = true; 13097 app._container = rootContainer; 13098 rootContainer.__vue_app__ = app; 13099 if (true) { 13100 app._instance = vnode.component; 13101 devtoolsInitApp(app, version); 13102 } 13103 return getComponentPublicInstance(vnode.component); 13104 } else if (true) { 13105 warn$1( 13106 `App has already been mounted. 13107If you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. \`const createMyApp = () => createApp(App)\`` 13108 ); 13109 } 13110 }, 13111 onUnmount(cleanupFn) { 13112 if ( true && typeof cleanupFn !== "function") { 13113 warn$1( 13114 `Expected function as first argument to app.onUnmount(), but got ${typeof cleanupFn}` 13115 ); 13116 } 13117 pluginCleanupFns.push(cleanupFn); 13118 }, 13119 unmount() { 13120 if (isMounted) { 13121 callWithAsyncErrorHandling( 13122 pluginCleanupFns, 13123 app._instance, 13124 16 13125 ); 13126 render(null, app._container); 13127 if (true) { 13128 app._instance = null; 13129 devtoolsUnmountApp(app); 13130 } 13131 delete app._container.__vue_app__; 13132 } else if (true) { 13133 warn$1(`Cannot unmount an app that is not mounted.`); 13134 } 13135 }, 13136 provide(key, value) { 13137 if ( true && key in context.provides) { 13138 warn$1( 13139 `App already provides property with key "${String(key)}". It will be overwritten with the new value.` 13140 ); 13141 } 13142 context.provides[key] = value; 13143 return app; 13144 }, 13145 runWithContext(fn) { 13146 const lastApp = currentApp; 13147 currentApp = app; 13148 try { 13149 return fn(); 13150 } finally { 13151 currentApp = lastApp; 13152 } 13153 } 13154 }; 13155 return app; 13156 }; 13157} 13158let currentApp = null; 13159 13160function provide(key, value) { 13161 if (!currentInstance) { 13162 if (true) { 13163 warn$1(`provide() can only be used inside setup().`); 13164 } 13165 } else { 13166 let provides = currentInstance.provides; 13167 const parentProvides = currentInstance.parent && currentInstance.parent.provides; 13168 if (parentProvides === provides) { 13169 provides = currentInstance.provides = Object.create(parentProvides); 13170 } 13171 provides[key] = value; 13172 } 13173} 13174function inject(key, defaultValue, treatDefaultAsFactory = false) { 13175 const instance = currentInstance || currentRenderingInstance; 13176 if (instance || currentApp) { 13177 const provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0; 13178 if (provides && key in provides) { 13179 return provides[key]; 13180 } else if (arguments.length > 1) { 13181 return treatDefaultAsFactory && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue; 13182 } else if (true) { 13183 warn$1(`injection "${String(key)}" not found.`); 13184 } 13185 } else if (true) { 13186 warn$1(`inject() can only be used inside setup() or functional components.`); 13187 } 13188} 13189function hasInjectionContext() { 13190 return !!(currentInstance || currentRenderingInstance || currentApp); 13191} 13192 13193const internalObjectProto = {}; 13194const createInternalObject = () => Object.create(internalObjectProto); 13195const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto; 13196 13197function initProps(instance, rawProps, isStateful, isSSR = false) { 13198 const props = {}; 13199 const attrs = createInternalObject(); 13200 instance.propsDefaults = /* @__PURE__ */ Object.create(null); 13201 setFullProps(instance, rawProps, props, attrs); 13202 for (const key in instance.propsOptions[0]) { 13203 if (!(key in props)) { 13204 props[key] = void 0; 13205 } 13206 } 13207 if (true) { 13208 validateProps(rawProps || {}, props, instance); 13209 } 13210 if (isStateful) { 13211 instance.props = isSSR ? props : (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReactive)(props); 13212 } else { 13213 if (!instance.type.props) { 13214 instance.props = attrs; 13215 } else { 13216 instance.props = props; 13217 } 13218 } 13219 instance.attrs = attrs; 13220} 13221function isInHmrContext(instance) { 13222 while (instance) { 13223 if (instance.type.__hmrId) return true; 13224 instance = instance.parent; 13225 } 13226} 13227function updateProps(instance, rawProps, rawPrevProps, optimized) { 13228 const { 13229 props, 13230 attrs, 13231 vnode: { patchFlag } 13232 } = instance; 13233 const rawCurrentProps = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props); 13234 const [options] = instance.propsOptions; 13235 let hasAttrsChanged = false; 13236 if ( 13237 // always force full diff in dev 13238 // - #1942 if hmr is enabled with sfc component 13239 // - vite#872 non-sfc component used by sfc component 13240 !( true && isInHmrContext(instance)) && (optimized || patchFlag > 0) && !(patchFlag & 16) 13241 ) { 13242 if (patchFlag & 8) { 13243 const propsToUpdate = instance.vnode.dynamicProps; 13244 for (let i = 0; i < propsToUpdate.length; i++) { 13245 let key = propsToUpdate[i]; 13246 if (isEmitListener(instance.emitsOptions, key)) { 13247 continue; 13248 } 13249 const value = rawProps[key]; 13250 if (options) { 13251 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(attrs, key)) { 13252 if (value !== attrs[key]) { 13253 attrs[key] = value; 13254 hasAttrsChanged = true; 13255 } 13256 } else { 13257 const camelizedKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key); 13258 props[camelizedKey] = resolvePropValue( 13259 options, 13260 rawCurrentProps, 13261 camelizedKey, 13262 value, 13263 instance, 13264 false 13265 ); 13266 } 13267 } else { 13268 if (value !== attrs[key]) { 13269 attrs[key] = value; 13270 hasAttrsChanged = true; 13271 } 13272 } 13273 } 13274 } 13275 } else { 13276 if (setFullProps(instance, rawProps, props, attrs)) { 13277 hasAttrsChanged = true; 13278 } 13279 let kebabKey; 13280 for (const key in rawCurrentProps) { 13281 if (!rawProps || // for camelCase 13282 !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, key) && // it's possible the original props was passed in as kebab-case 13283 // and converted to camelCase (#955) 13284 ((kebabKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key)) === key || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, kebabKey))) { 13285 if (options) { 13286 if (rawPrevProps && // for camelCase 13287 (rawPrevProps[key] !== void 0 || // for kebab-case 13288 rawPrevProps[kebabKey] !== void 0)) { 13289 props[key] = resolvePropValue( 13290 options, 13291 rawCurrentProps, 13292 key, 13293 void 0, 13294 instance, 13295 true 13296 ); 13297 } 13298 } else { 13299 delete props[key]; 13300 } 13301 } 13302 } 13303 if (attrs !== rawCurrentProps) { 13304 for (const key in attrs) { 13305 if (!rawProps || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, key) && true) { 13306 delete attrs[key]; 13307 hasAttrsChanged = true; 13308 } 13309 } 13310 } 13311 } 13312 if (hasAttrsChanged) { 13313 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.trigger)(instance.attrs, "set", ""); 13314 } 13315 if (true) { 13316 validateProps(rawProps || {}, props, instance); 13317 } 13318} 13319function setFullProps(instance, rawProps, props, attrs) { 13320 const [options, needCastKeys] = instance.propsOptions; 13321 let hasAttrsChanged = false; 13322 let rawCastValues; 13323 if (rawProps) { 13324 for (let key in rawProps) { 13325 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) { 13326 continue; 13327 } 13328 const value = rawProps[key]; 13329 let camelKey; 13330 if (options && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, camelKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key))) { 13331 if (!needCastKeys || !needCastKeys.includes(camelKey)) { 13332 props[camelKey] = value; 13333 } else { 13334 (rawCastValues || (rawCastValues = {}))[camelKey] = value; 13335 } 13336 } else if (!isEmitListener(instance.emitsOptions, key)) { 13337 if (!(key in attrs) || value !== attrs[key]) { 13338 attrs[key] = value; 13339 hasAttrsChanged = true; 13340 } 13341 } 13342 } 13343 } 13344 if (needCastKeys) { 13345 const rawCurrentProps = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props); 13346 const castValues = rawCastValues || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 13347 for (let i = 0; i < needCastKeys.length; i++) { 13348 const key = needCastKeys[i]; 13349 props[key] = resolvePropValue( 13350 options, 13351 rawCurrentProps, 13352 key, 13353 castValues[key], 13354 instance, 13355 !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(castValues, key) 13356 ); 13357 } 13358 } 13359 return hasAttrsChanged; 13360} 13361function resolvePropValue(options, props, key, value, instance, isAbsent) { 13362 const opt = options[key]; 13363 if (opt != null) { 13364 const hasDefault = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(opt, "default"); 13365 if (hasDefault && value === void 0) { 13366 const defaultValue = opt.default; 13367 if (opt.type !== Function && !opt.skipFactory && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(defaultValue)) { 13368 const { propsDefaults } = instance; 13369 if (key in propsDefaults) { 13370 value = propsDefaults[key]; 13371 } else { 13372 const reset = setCurrentInstance(instance); 13373 value = propsDefaults[key] = defaultValue.call( 13374 null, 13375 props 13376 ); 13377 reset(); 13378 } 13379 } else { 13380 value = defaultValue; 13381 } 13382 if (instance.ce) { 13383 instance.ce._setProp(key, value); 13384 } 13385 } 13386 if (opt[0 /* shouldCast */]) { 13387 if (isAbsent && !hasDefault) { 13388 value = false; 13389 } else if (opt[1 /* shouldCastTrue */] && (value === "" || value === (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key))) { 13390 value = true; 13391 } 13392 } 13393 } 13394 return value; 13395} 13396const mixinPropsCache = /* @__PURE__ */ new WeakMap(); 13397function normalizePropsOptions(comp, appContext, asMixin = false) { 13398 const cache = true && asMixin ? mixinPropsCache : appContext.propsCache; 13399 const cached = cache.get(comp); 13400 if (cached) { 13401 return cached; 13402 } 13403 const raw = comp.props; 13404 const normalized = {}; 13405 const needCastKeys = []; 13406 let hasExtends = false; 13407 if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(comp)) { 13408 const extendProps = (raw2) => { 13409 hasExtends = true; 13410 const [props, keys] = normalizePropsOptions(raw2, appContext, true); 13411 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(normalized, props); 13412 if (keys) needCastKeys.push(...keys); 13413 }; 13414 if (!asMixin && appContext.mixins.length) { 13415 appContext.mixins.forEach(extendProps); 13416 } 13417 if (comp.extends) { 13418 extendProps(comp.extends); 13419 } 13420 if (comp.mixins) { 13421 comp.mixins.forEach(extendProps); 13422 } 13423 } 13424 if (!raw && !hasExtends) { 13425 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) { 13426 cache.set(comp, _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR); 13427 } 13428 return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR; 13429 } 13430 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) { 13431 for (let i = 0; i < raw.length; i++) { 13432 if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(raw[i])) { 13433 warn$1(`props must be strings when using array syntax.`, raw[i]); 13434 } 13435 const normalizedKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(raw[i]); 13436 if (validatePropName(normalizedKey)) { 13437 normalized[normalizedKey] = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 13438 } 13439 } 13440 } else if (raw) { 13441 if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(raw)) { 13442 warn$1(`invalid props options`, raw); 13443 } 13444 for (const key in raw) { 13445 const normalizedKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key); 13446 if (validatePropName(normalizedKey)) { 13447 const opt = raw[key]; 13448 const prop = normalized[normalizedKey] = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(opt) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt) ? { type: opt } : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, opt); 13449 const propType = prop.type; 13450 let shouldCast = false; 13451 let shouldCastTrue = true; 13452 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(propType)) { 13453 for (let index = 0; index < propType.length; ++index) { 13454 const type = propType[index]; 13455 const typeName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(type) && type.name; 13456 if (typeName === "Boolean") { 13457 shouldCast = true; 13458 break; 13459 } else if (typeName === "String") { 13460 shouldCastTrue = false; 13461 } 13462 } 13463 } else { 13464 shouldCast = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(propType) && propType.name === "Boolean"; 13465 } 13466 prop[0 /* shouldCast */] = shouldCast; 13467 prop[1 /* shouldCastTrue */] = shouldCastTrue; 13468 if (shouldCast || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(prop, "default")) { 13469 needCastKeys.push(normalizedKey); 13470 } 13471 } 13472 } 13473 } 13474 const res = [normalized, needCastKeys]; 13475 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) { 13476 cache.set(comp, res); 13477 } 13478 return res; 13479} 13480function validatePropName(key) { 13481 if (key[0] !== "$" && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) { 13482 return true; 13483 } else if (true) { 13484 warn$1(`Invalid prop name: "${key}" is a reserved property.`); 13485 } 13486 return false; 13487} 13488function getType(ctor) { 13489 if (ctor === null) { 13490 return "null"; 13491 } 13492 if (typeof ctor === "function") { 13493 return ctor.name || ""; 13494 } else if (typeof ctor === "object") { 13495 const name = ctor.constructor && ctor.constructor.name; 13496 return name || ""; 13497 } 13498 return ""; 13499} 13500function validateProps(rawProps, props, instance) { 13501 const resolvedValues = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props); 13502 const options = instance.propsOptions[0]; 13503 const camelizePropsKey = Object.keys(rawProps).map((key) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key)); 13504 for (const key in options) { 13505 let opt = options[key]; 13506 if (opt == null) continue; 13507 validateProp( 13508 key, 13509 resolvedValues[key], 13510 opt, 13511 true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(resolvedValues) : 0, 13512 !camelizePropsKey.includes(key) 13513 ); 13514 } 13515} 13516function validateProp(name, value, prop, props, isAbsent) { 13517 const { type, required, validator, skipCheck } = prop; 13518 if (required && isAbsent) { 13519 warn$1('Missing required prop: "' + name + '"'); 13520 return; 13521 } 13522 if (value == null && !required) { 13523 return; 13524 } 13525 if (type != null && type !== true && !skipCheck) { 13526 let isValid = false; 13527 const types = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(type) ? type : [type]; 13528 const expectedTypes = []; 13529 for (let i = 0; i < types.length && !isValid; i++) { 13530 const { valid, expectedType } = assertType(value, types[i]); 13531 expectedTypes.push(expectedType || ""); 13532 isValid = valid; 13533 } 13534 if (!isValid) { 13535 warn$1(getInvalidTypeMessage(name, value, expectedTypes)); 13536 return; 13537 } 13538 } 13539 if (validator && !validator(value, props)) { 13540 warn$1('Invalid prop: custom validator check failed for prop "' + name + '".'); 13541 } 13542} 13543const isSimpleType = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)( 13544 "String,Number,Boolean,Function,Symbol,BigInt" 13545); 13546function assertType(value, type) { 13547 let valid; 13548 const expectedType = getType(type); 13549 if (expectedType === "null") { 13550 valid = value === null; 13551 } else if (isSimpleType(expectedType)) { 13552 const t = typeof value; 13553 valid = t === expectedType.toLowerCase(); 13554 if (!valid && t === "object") { 13555 valid = value instanceof type; 13556 } 13557 } else if (expectedType === "Object") { 13558 valid = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(value); 13559 } else if (expectedType === "Array") { 13560 valid = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value); 13561 } else { 13562 valid = value instanceof type; 13563 } 13564 return { 13565 valid, 13566 expectedType 13567 }; 13568} 13569function getInvalidTypeMessage(name, value, expectedTypes) { 13570 if (expectedTypes.length === 0) { 13571 return `Prop type [] for prop "${name}" won't match anything. Did you mean to use type Array instead?`; 13572 } 13573 let message = `Invalid prop: type check failed for prop "${name}". Expected ${expectedTypes.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize).join(" | ")}`; 13574 const expectedType = expectedTypes[0]; 13575 const receivedType = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toRawType)(value); 13576 const expectedValue = styleValue(value, expectedType); 13577 const receivedValue = styleValue(value, receivedType); 13578 if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) { 13579 message += ` with value ${expectedValue}`; 13580 } 13581 message += `, got ${receivedType} `; 13582 if (isExplicable(receivedType)) { 13583 message += `with value ${receivedValue}.`; 13584 } 13585 return message; 13586} 13587function styleValue(value, type) { 13588 if (type === "String") { 13589 return `"${value}"`; 13590 } else if (type === "Number") { 13591 return `${Number(value)}`; 13592 } else { 13593 return `${value}`; 13594 } 13595} 13596function isExplicable(type) { 13597 const explicitTypes = ["string", "number", "boolean"]; 13598 return explicitTypes.some((elem) => type.toLowerCase() === elem); 13599} 13600function isBoolean(...args) { 13601 return args.some((elem) => elem.toLowerCase() === "boolean"); 13602} 13603 13604const isInternalKey = (key) => key[0] === "_" || key === "$stable"; 13605const normalizeSlotValue = (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value) ? value.map(normalizeVNode) : [normalizeVNode(value)]; 13606const normalizeSlot = (key, rawSlot, ctx) => { 13607 if (rawSlot._n) { 13608 return rawSlot; 13609 } 13610 const normalized = withCtx((...args) => { 13611 if ( true && currentInstance && (!ctx || ctx.root === currentInstance.root)) { 13612 warn$1( 13613 `Slot "${key}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.` 13614 ); 13615 } 13616 return normalizeSlotValue(rawSlot(...args)); 13617 }, ctx); 13618 normalized._c = false; 13619 return normalized; 13620}; 13621const normalizeObjectSlots = (rawSlots, slots, instance) => { 13622 const ctx = rawSlots._ctx; 13623 for (const key in rawSlots) { 13624 if (isInternalKey(key)) continue; 13625 const value = rawSlots[key]; 13626 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) { 13627 slots[key] = normalizeSlot(key, value, ctx); 13628 } else if (value != null) { 13629 if (true) { 13630 warn$1( 13631 `Non-function value encountered for slot "${key}". Prefer function slots for better performance.` 13632 ); 13633 } 13634 const normalized = normalizeSlotValue(value); 13635 slots[key] = () => normalized; 13636 } 13637 } 13638}; 13639const normalizeVNodeSlots = (instance, children) => { 13640 if ( true && !isKeepAlive(instance.vnode) && true) { 13641 warn$1( 13642 `Non-function value encountered for default slot. Prefer function slots for better performance.` 13643 ); 13644 } 13645 const normalized = normalizeSlotValue(children); 13646 instance.slots.default = () => normalized; 13647}; 13648const assignSlots = (slots, children, optimized) => { 13649 for (const key in children) { 13650 if (optimized || key !== "_") { 13651 slots[key] = children[key]; 13652 } 13653 } 13654}; 13655const initSlots = (instance, children, optimized) => { 13656 const slots = instance.slots = createInternalObject(); 13657 if (instance.vnode.shapeFlag & 32) { 13658 const type = children._; 13659 if (type) { 13660 assignSlots(slots, children, optimized); 13661 if (optimized) { 13662 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(slots, "_", type, true); 13663 } 13664 } else { 13665 normalizeObjectSlots(children, slots); 13666 } 13667 } else if (children) { 13668 normalizeVNodeSlots(instance, children); 13669 } 13670}; 13671const updateSlots = (instance, children, optimized) => { 13672 const { vnode, slots } = instance; 13673 let needDeletionCheck = true; 13674 let deletionComparisonTarget = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 13675 if (vnode.shapeFlag & 32) { 13676 const type = children._; 13677 if (type) { 13678 if ( true && isHmrUpdating) { 13679 assignSlots(slots, children, optimized); 13680 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.trigger)(instance, "set", "$slots"); 13681 } else if (optimized && type === 1) { 13682 needDeletionCheck = false; 13683 } else { 13684 assignSlots(slots, children, optimized); 13685 } 13686 } else { 13687 needDeletionCheck = !children.$stable; 13688 normalizeObjectSlots(children, slots); 13689 } 13690 deletionComparisonTarget = children; 13691 } else if (children) { 13692 normalizeVNodeSlots(instance, children); 13693 deletionComparisonTarget = { default: 1 }; 13694 } 13695 if (needDeletionCheck) { 13696 for (const key in slots) { 13697 if (!isInternalKey(key) && deletionComparisonTarget[key] == null) { 13698 delete slots[key]; 13699 } 13700 } 13701 } 13702}; 13703 13704let supported; 13705let perf; 13706function startMeasure(instance, type) { 13707 if (instance.appContext.config.performance && isSupported()) { 13708 perf.mark(`vue-${type}-${instance.uid}`); 13709 } 13710 if (true) { 13711 devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now()); 13712 } 13713} 13714function endMeasure(instance, type) { 13715 if (instance.appContext.config.performance && isSupported()) { 13716 const startTag = `vue-${type}-${instance.uid}`; 13717 const endTag = startTag + `:end`; 13718 perf.mark(endTag); 13719 perf.measure( 13720 `<${formatComponentName(instance, instance.type)}> ${type}`, 13721 startTag, 13722 endTag 13723 ); 13724 perf.clearMarks(startTag); 13725 perf.clearMarks(endTag); 13726 } 13727 if (true) { 13728 devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now()); 13729 } 13730} 13731function isSupported() { 13732 if (supported !== void 0) { 13733 return supported; 13734 } 13735 if (typeof window !== "undefined" && window.performance) { 13736 supported = true; 13737 perf = window.performance; 13738 } else { 13739 supported = false; 13740 } 13741 return supported; 13742} 13743 13744function initFeatureFlags() { 13745 const needWarn = []; 13746 if (false) {} 13747 if (false) {} 13748 if (false) {} 13749 if ( true && needWarn.length) { 13750 const multi = needWarn.length > 1; 13751 console.warn( 13752 `Feature flag${multi ? `s` : ``} ${needWarn.join(", ")} ${multi ? `are` : `is`} not explicitly defined. You are running the esm-bundler build of Vue, which expects these compile-time feature flags to be globally injected via the bundler config in order to get better tree-shaking in the production bundle. 13753 13754For more details, see https://link.vuejs.org/feature-flags.` 13755 ); 13756 } 13757} 13758 13759const queuePostRenderEffect = queueEffectWithSuspense ; 13760function createRenderer(options) { 13761 return baseCreateRenderer(options); 13762} 13763function createHydrationRenderer(options) { 13764 return baseCreateRenderer(options, createHydrationFunctions); 13765} 13766function baseCreateRenderer(options, createHydrationFns) { 13767 { 13768 initFeatureFlags(); 13769 } 13770 const target = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)(); 13771 target.__VUE__ = true; 13772 if (true) { 13773 setDevtoolsHook$1(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target); 13774 } 13775 const { 13776 insert: hostInsert, 13777 remove: hostRemove, 13778 patchProp: hostPatchProp, 13779 createElement: hostCreateElement, 13780 createText: hostCreateText, 13781 createComment: hostCreateComment, 13782 setText: hostSetText, 13783 setElementText: hostSetElementText, 13784 parentNode: hostParentNode, 13785 nextSibling: hostNextSibling, 13786 setScopeId: hostSetScopeId = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP, 13787 insertStaticContent: hostInsertStaticContent 13788 } = options; 13789 const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, namespace = void 0, slotScopeIds = null, optimized = true && isHmrUpdating ? false : !!n2.dynamicChildren) => { 13790 if (n1 === n2) { 13791 return; 13792 } 13793 if (n1 && !isSameVNodeType(n1, n2)) { 13794 anchor = getNextHostNode(n1); 13795 unmount(n1, parentComponent, parentSuspense, true); 13796 n1 = null; 13797 } 13798 if (n2.patchFlag === -2) { 13799 optimized = false; 13800 n2.dynamicChildren = null; 13801 } 13802 const { type, ref, shapeFlag } = n2; 13803 switch (type) { 13804 case Text: 13805 processText(n1, n2, container, anchor); 13806 break; 13807 case Comment: 13808 processCommentNode(n1, n2, container, anchor); 13809 break; 13810 case Static: 13811 if (n1 == null) { 13812 mountStaticNode(n2, container, anchor, namespace); 13813 } else if (true) { 13814 patchStaticNode(n1, n2, container, namespace); 13815 } 13816 break; 13817 case Fragment: 13818 processFragment( 13819 n1, 13820 n2, 13821 container, 13822 anchor, 13823 parentComponent, 13824 parentSuspense, 13825 namespace, 13826 slotScopeIds, 13827 optimized 13828 ); 13829 break; 13830 default: 13831 if (shapeFlag & 1) { 13832 processElement( 13833 n1, 13834 n2, 13835 container, 13836 anchor, 13837 parentComponent, 13838 parentSuspense, 13839 namespace, 13840 slotScopeIds, 13841 optimized 13842 ); 13843 } else if (shapeFlag & 6) { 13844 processComponent( 13845 n1, 13846 n2, 13847 container, 13848 anchor, 13849 parentComponent, 13850 parentSuspense, 13851 namespace, 13852 slotScopeIds, 13853 optimized 13854 ); 13855 } else if (shapeFlag & 64) { 13856 type.process( 13857 n1, 13858 n2, 13859 container, 13860 anchor, 13861 parentComponent, 13862 parentSuspense, 13863 namespace, 13864 slotScopeIds, 13865 optimized, 13866 internals 13867 ); 13868 } else if (shapeFlag & 128) { 13869 type.process( 13870 n1, 13871 n2, 13872 container, 13873 anchor, 13874 parentComponent, 13875 parentSuspense, 13876 namespace, 13877 slotScopeIds, 13878 optimized, 13879 internals 13880 ); 13881 } else if (true) { 13882 warn$1("Invalid VNode type:", type, `(${typeof type})`); 13883 } 13884 } 13885 if (ref != null && parentComponent) { 13886 setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2); 13887 } 13888 }; 13889 const processText = (n1, n2, container, anchor) => { 13890 if (n1 == null) { 13891 hostInsert( 13892 n2.el = hostCreateText(n2.children), 13893 container, 13894 anchor 13895 ); 13896 } else { 13897 const el = n2.el = n1.el; 13898 if (n2.children !== n1.children) { 13899 hostSetText(el, n2.children); 13900 } 13901 } 13902 }; 13903 const processCommentNode = (n1, n2, container, anchor) => { 13904 if (n1 == null) { 13905 hostInsert( 13906 n2.el = hostCreateComment(n2.children || ""), 13907 container, 13908 anchor 13909 ); 13910 } else { 13911 n2.el = n1.el; 13912 } 13913 }; 13914 const mountStaticNode = (n2, container, anchor, namespace) => { 13915 [n2.el, n2.anchor] = hostInsertStaticContent( 13916 n2.children, 13917 container, 13918 anchor, 13919 namespace, 13920 n2.el, 13921 n2.anchor 13922 ); 13923 }; 13924 const patchStaticNode = (n1, n2, container, namespace) => { 13925 if (n2.children !== n1.children) { 13926 const anchor = hostNextSibling(n1.anchor); 13927 removeStaticNode(n1); 13928 [n2.el, n2.anchor] = hostInsertStaticContent( 13929 n2.children, 13930 container, 13931 anchor, 13932 namespace 13933 ); 13934 } else { 13935 n2.el = n1.el; 13936 n2.anchor = n1.anchor; 13937 } 13938 }; 13939 const moveStaticNode = ({ el, anchor }, container, nextSibling) => { 13940 let next; 13941 while (el && el !== anchor) { 13942 next = hostNextSibling(el); 13943 hostInsert(el, container, nextSibling); 13944 el = next; 13945 } 13946 hostInsert(anchor, container, nextSibling); 13947 }; 13948 const removeStaticNode = ({ el, anchor }) => { 13949 let next; 13950 while (el && el !== anchor) { 13951 next = hostNextSibling(el); 13952 hostRemove(el); 13953 el = next; 13954 } 13955 hostRemove(anchor); 13956 }; 13957 const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => { 13958 if (n2.type === "svg") { 13959 namespace = "svg"; 13960 } else if (n2.type === "math") { 13961 namespace = "mathml"; 13962 } 13963 if (n1 == null) { 13964 mountElement( 13965 n2, 13966 container, 13967 anchor, 13968 parentComponent, 13969 parentSuspense, 13970 namespace, 13971 slotScopeIds, 13972 optimized 13973 ); 13974 } else { 13975 patchElement( 13976 n1, 13977 n2, 13978 parentComponent, 13979 parentSuspense, 13980 namespace, 13981 slotScopeIds, 13982 optimized 13983 ); 13984 } 13985 }; 13986 const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => { 13987 let el; 13988 let vnodeHook; 13989 const { props, shapeFlag, transition, dirs } = vnode; 13990 el = vnode.el = hostCreateElement( 13991 vnode.type, 13992 namespace, 13993 props && props.is, 13994 props 13995 ); 13996 if (shapeFlag & 8) { 13997 hostSetElementText(el, vnode.children); 13998 } else if (shapeFlag & 16) { 13999 mountChildren( 14000 vnode.children, 14001 el, 14002 null, 14003 parentComponent, 14004 parentSuspense, 14005 resolveChildrenNamespace(vnode, namespace), 14006 slotScopeIds, 14007 optimized 14008 ); 14009 } 14010 if (dirs) { 14011 invokeDirectiveHook(vnode, null, parentComponent, "created"); 14012 } 14013 setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent); 14014 if (props) { 14015 for (const key in props) { 14016 if (key !== "value" && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) { 14017 hostPatchProp(el, key, null, props[key], namespace, parentComponent); 14018 } 14019 } 14020 if ("value" in props) { 14021 hostPatchProp(el, "value", null, props.value, namespace); 14022 } 14023 if (vnodeHook = props.onVnodeBeforeMount) { 14024 invokeVNodeHook(vnodeHook, parentComponent, vnode); 14025 } 14026 } 14027 if (true) { 14028 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(el, "__vnode", vnode, true); 14029 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(el, "__vueParentComponent", parentComponent, true); 14030 } 14031 if (dirs) { 14032 invokeDirectiveHook(vnode, null, parentComponent, "beforeMount"); 14033 } 14034 const needCallTransitionHooks = needTransition(parentSuspense, transition); 14035 if (needCallTransitionHooks) { 14036 transition.beforeEnter(el); 14037 } 14038 hostInsert(el, container, anchor); 14039 if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) { 14040 queuePostRenderEffect(() => { 14041 vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode); 14042 needCallTransitionHooks && transition.enter(el); 14043 dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted"); 14044 }, parentSuspense); 14045 } 14046 }; 14047 const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => { 14048 if (scopeId) { 14049 hostSetScopeId(el, scopeId); 14050 } 14051 if (slotScopeIds) { 14052 for (let i = 0; i < slotScopeIds.length; i++) { 14053 hostSetScopeId(el, slotScopeIds[i]); 14054 } 14055 } 14056 if (parentComponent) { 14057 let subTree = parentComponent.subTree; 14058 if ( true && subTree.patchFlag > 0 && subTree.patchFlag & 2048) { 14059 subTree = filterSingleRoot(subTree.children) || subTree; 14060 } 14061 if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) { 14062 const parentVNode = parentComponent.vnode; 14063 setScopeId( 14064 el, 14065 parentVNode, 14066 parentVNode.scopeId, 14067 parentVNode.slotScopeIds, 14068 parentComponent.parent 14069 ); 14070 } 14071 } 14072 }; 14073 const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => { 14074 for (let i = start; i < children.length; i++) { 14075 const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]); 14076 patch( 14077 null, 14078 child, 14079 container, 14080 anchor, 14081 parentComponent, 14082 parentSuspense, 14083 namespace, 14084 slotScopeIds, 14085 optimized 14086 ); 14087 } 14088 }; 14089 const patchElement = (n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => { 14090 const el = n2.el = n1.el; 14091 if (true) { 14092 el.__vnode = n2; 14093 } 14094 let { patchFlag, dynamicChildren, dirs } = n2; 14095 patchFlag |= n1.patchFlag & 16; 14096 const oldProps = n1.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 14097 const newProps = n2.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 14098 let vnodeHook; 14099 parentComponent && toggleRecurse(parentComponent, false); 14100 if (vnodeHook = newProps.onVnodeBeforeUpdate) { 14101 invokeVNodeHook(vnodeHook, parentComponent, n2, n1); 14102 } 14103 if (dirs) { 14104 invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate"); 14105 } 14106 parentComponent && toggleRecurse(parentComponent, true); 14107 if ( true && isHmrUpdating) { 14108 patchFlag = 0; 14109 optimized = false; 14110 dynamicChildren = null; 14111 } 14112 if (oldProps.innerHTML && newProps.innerHTML == null || oldProps.textContent && newProps.textContent == null) { 14113 hostSetElementText(el, ""); 14114 } 14115 if (dynamicChildren) { 14116 patchBlockChildren( 14117 n1.dynamicChildren, 14118 dynamicChildren, 14119 el, 14120 parentComponent, 14121 parentSuspense, 14122 resolveChildrenNamespace(n2, namespace), 14123 slotScopeIds 14124 ); 14125 if (true) { 14126 traverseStaticChildren(n1, n2); 14127 } 14128 } else if (!optimized) { 14129 patchChildren( 14130 n1, 14131 n2, 14132 el, 14133 null, 14134 parentComponent, 14135 parentSuspense, 14136 resolveChildrenNamespace(n2, namespace), 14137 slotScopeIds, 14138 false 14139 ); 14140 } 14141 if (patchFlag > 0) { 14142 if (patchFlag & 16) { 14143 patchProps(el, oldProps, newProps, parentComponent, namespace); 14144 } else { 14145 if (patchFlag & 2) { 14146 if (oldProps.class !== newProps.class) { 14147 hostPatchProp(el, "class", null, newProps.class, namespace); 14148 } 14149 } 14150 if (patchFlag & 4) { 14151 hostPatchProp(el, "style", oldProps.style, newProps.style, namespace); 14152 } 14153 if (patchFlag & 8) { 14154 const propsToUpdate = n2.dynamicProps; 14155 for (let i = 0; i < propsToUpdate.length; i++) { 14156 const key = propsToUpdate[i]; 14157 const prev = oldProps[key]; 14158 const next = newProps[key]; 14159 if (next !== prev || key === "value") { 14160 hostPatchProp(el, key, prev, next, namespace, parentComponent); 14161 } 14162 } 14163 } 14164 } 14165 if (patchFlag & 1) { 14166 if (n1.children !== n2.children) { 14167 hostSetElementText(el, n2.children); 14168 } 14169 } 14170 } else if (!optimized && dynamicChildren == null) { 14171 patchProps(el, oldProps, newProps, parentComponent, namespace); 14172 } 14173 if ((vnodeHook = newProps.onVnodeUpdated) || dirs) { 14174 queuePostRenderEffect(() => { 14175 vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1); 14176 dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated"); 14177 }, parentSuspense); 14178 } 14179 }; 14180 const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => { 14181 for (let i = 0; i < newChildren.length; i++) { 14182 const oldVNode = oldChildren[i]; 14183 const newVNode = newChildren[i]; 14184 const container = ( 14185 // oldVNode may be an errored async setup() component inside Suspense 14186 // which will not have a mounted element 14187 oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent 14188 // of the Fragment itself so it can move its children. 14189 (oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement 14190 // which also requires the correct parent container 14191 !isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything. 14192 oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : ( 14193 // In other cases, the parent container is not actually used so we 14194 // just pass the block element here to avoid a DOM parentNode call. 14195 fallbackContainer 14196 ) 14197 ); 14198 patch( 14199 oldVNode, 14200 newVNode, 14201 container, 14202 null, 14203 parentComponent, 14204 parentSuspense, 14205 namespace, 14206 slotScopeIds, 14207 true 14208 ); 14209 } 14210 }; 14211 const patchProps = (el, oldProps, newProps, parentComponent, namespace) => { 14212 if (oldProps !== newProps) { 14213 if (oldProps !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) { 14214 for (const key in oldProps) { 14215 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key) && !(key in newProps)) { 14216 hostPatchProp( 14217 el, 14218 key, 14219 oldProps[key], 14220 null, 14221 namespace, 14222 parentComponent 14223 ); 14224 } 14225 } 14226 } 14227 for (const key in newProps) { 14228 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) continue; 14229 const next = newProps[key]; 14230 const prev = oldProps[key]; 14231 if (next !== prev && key !== "value") { 14232 hostPatchProp(el, key, prev, next, namespace, parentComponent); 14233 } 14234 } 14235 if ("value" in newProps) { 14236 hostPatchProp(el, "value", oldProps.value, newProps.value, namespace); 14237 } 14238 } 14239 }; 14240 const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => { 14241 const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText(""); 14242 const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText(""); 14243 let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2; 14244 if ( true && // #5523 dev root fragment may inherit directives 14245 (isHmrUpdating || patchFlag & 2048)) { 14246 patchFlag = 0; 14247 optimized = false; 14248 dynamicChildren = null; 14249 } 14250 if (fragmentSlotScopeIds) { 14251 slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds; 14252 } 14253 if (n1 == null) { 14254 hostInsert(fragmentStartAnchor, container, anchor); 14255 hostInsert(fragmentEndAnchor, container, anchor); 14256 mountChildren( 14257 // #10007 14258 // such fragment like `<></>` will be compiled into 14259 // a fragment which doesn't have a children. 14260 // In this case fallback to an empty array 14261 n2.children || [], 14262 container, 14263 fragmentEndAnchor, 14264 parentComponent, 14265 parentSuspense, 14266 namespace, 14267 slotScopeIds, 14268 optimized 14269 ); 14270 } else { 14271 if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result 14272 // of renderSlot() with no valid children 14273 n1.dynamicChildren) { 14274 patchBlockChildren( 14275 n1.dynamicChildren, 14276 dynamicChildren, 14277 container, 14278 parentComponent, 14279 parentSuspense, 14280 namespace, 14281 slotScopeIds 14282 ); 14283 if (true) { 14284 traverseStaticChildren(n1, n2); 14285 } else {} 14286 } else { 14287 patchChildren( 14288 n1, 14289 n2, 14290 container, 14291 fragmentEndAnchor, 14292 parentComponent, 14293 parentSuspense, 14294 namespace, 14295 slotScopeIds, 14296 optimized 14297 ); 14298 } 14299 } 14300 }; 14301 const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => { 14302 n2.slotScopeIds = slotScopeIds; 14303 if (n1 == null) { 14304 if (n2.shapeFlag & 512) { 14305 parentComponent.ctx.activate( 14306 n2, 14307 container, 14308 anchor, 14309 namespace, 14310 optimized 14311 ); 14312 } else { 14313 mountComponent( 14314 n2, 14315 container, 14316 anchor, 14317 parentComponent, 14318 parentSuspense, 14319 namespace, 14320 optimized 14321 ); 14322 } 14323 } else { 14324 updateComponent(n1, n2, optimized); 14325 } 14326 }; 14327 const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, namespace, optimized) => { 14328 const instance = (initialVNode.component = createComponentInstance( 14329 initialVNode, 14330 parentComponent, 14331 parentSuspense 14332 )); 14333 if ( true && instance.type.__hmrId) { 14334 registerHMR(instance); 14335 } 14336 if (true) { 14337 pushWarningContext(initialVNode); 14338 startMeasure(instance, `mount`); 14339 } 14340 if (isKeepAlive(initialVNode)) { 14341 instance.ctx.renderer = internals; 14342 } 14343 { 14344 if (true) { 14345 startMeasure(instance, `init`); 14346 } 14347 setupComponent(instance, false, optimized); 14348 if (true) { 14349 endMeasure(instance, `init`); 14350 } 14351 } 14352 if (instance.asyncDep) { 14353 if ( true && isHmrUpdating) initialVNode.el = null; 14354 parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect, optimized); 14355 if (!initialVNode.el) { 14356 const placeholder = instance.subTree = createVNode(Comment); 14357 processCommentNode(null, placeholder, container, anchor); 14358 } 14359 } else { 14360 setupRenderEffect( 14361 instance, 14362 initialVNode, 14363 container, 14364 anchor, 14365 parentSuspense, 14366 namespace, 14367 optimized 14368 ); 14369 } 14370 if (true) { 14371 popWarningContext(); 14372 endMeasure(instance, `mount`); 14373 } 14374 }; 14375 const updateComponent = (n1, n2, optimized) => { 14376 const instance = n2.component = n1.component; 14377 if (shouldUpdateComponent(n1, n2, optimized)) { 14378 if (instance.asyncDep && !instance.asyncResolved) { 14379 if (true) { 14380 pushWarningContext(n2); 14381 } 14382 updateComponentPreRender(instance, n2, optimized); 14383 if (true) { 14384 popWarningContext(); 14385 } 14386 return; 14387 } else { 14388 instance.next = n2; 14389 instance.update(); 14390 } 14391 } else { 14392 n2.el = n1.el; 14393 instance.vnode = n2; 14394 } 14395 }; 14396 const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => { 14397 const componentUpdateFn = () => { 14398 if (!instance.isMounted) { 14399 let vnodeHook; 14400 const { el, props } = initialVNode; 14401 const { bm, m, parent, root, type } = instance; 14402 const isAsyncWrapperVNode = isAsyncWrapper(initialVNode); 14403 toggleRecurse(instance, false); 14404 if (bm) { 14405 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(bm); 14406 } 14407 if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) { 14408 invokeVNodeHook(vnodeHook, parent, initialVNode); 14409 } 14410 toggleRecurse(instance, true); 14411 if (el && hydrateNode) { 14412 const hydrateSubTree = () => { 14413 if (true) { 14414 startMeasure(instance, `render`); 14415 } 14416 instance.subTree = renderComponentRoot(instance); 14417 if (true) { 14418 endMeasure(instance, `render`); 14419 } 14420 if (true) { 14421 startMeasure(instance, `hydrate`); 14422 } 14423 hydrateNode( 14424 el, 14425 instance.subTree, 14426 instance, 14427 parentSuspense, 14428 null 14429 ); 14430 if (true) { 14431 endMeasure(instance, `hydrate`); 14432 } 14433 }; 14434 if (isAsyncWrapperVNode && type.__asyncHydrate) { 14435 type.__asyncHydrate( 14436 el, 14437 instance, 14438 hydrateSubTree 14439 ); 14440 } else { 14441 hydrateSubTree(); 14442 } 14443 } else { 14444 if (root.ce) { 14445 root.ce._injectChildStyle(type); 14446 } 14447 if (true) { 14448 startMeasure(instance, `render`); 14449 } 14450 const subTree = instance.subTree = renderComponentRoot(instance); 14451 if (true) { 14452 endMeasure(instance, `render`); 14453 } 14454 if (true) { 14455 startMeasure(instance, `patch`); 14456 } 14457 patch( 14458 null, 14459 subTree, 14460 container, 14461 anchor, 14462 instance, 14463 parentSuspense, 14464 namespace 14465 ); 14466 if (true) { 14467 endMeasure(instance, `patch`); 14468 } 14469 initialVNode.el = subTree.el; 14470 } 14471 if (m) { 14472 queuePostRenderEffect(m, parentSuspense); 14473 } 14474 if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) { 14475 const scopedInitialVNode = initialVNode; 14476 queuePostRenderEffect( 14477 () => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode), 14478 parentSuspense 14479 ); 14480 } 14481 if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) { 14482 instance.a && queuePostRenderEffect(instance.a, parentSuspense); 14483 } 14484 instance.isMounted = true; 14485 if (true) { 14486 devtoolsComponentAdded(instance); 14487 } 14488 initialVNode = container = anchor = null; 14489 } else { 14490 let { next, bu, u, parent, vnode } = instance; 14491 { 14492 const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance); 14493 if (nonHydratedAsyncRoot) { 14494 if (next) { 14495 next.el = vnode.el; 14496 updateComponentPreRender(instance, next, optimized); 14497 } 14498 nonHydratedAsyncRoot.asyncDep.then(() => { 14499 if (!instance.isUnmounted) { 14500 componentUpdateFn(); 14501 } 14502 }); 14503 return; 14504 } 14505 } 14506 let originNext = next; 14507 let vnodeHook; 14508 if (true) { 14509 pushWarningContext(next || instance.vnode); 14510 } 14511 toggleRecurse(instance, false); 14512 if (next) { 14513 next.el = vnode.el; 14514 updateComponentPreRender(instance, next, optimized); 14515 } else { 14516 next = vnode; 14517 } 14518 if (bu) { 14519 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(bu); 14520 } 14521 if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) { 14522 invokeVNodeHook(vnodeHook, parent, next, vnode); 14523 } 14524 toggleRecurse(instance, true); 14525 if (true) { 14526 startMeasure(instance, `render`); 14527 } 14528 const nextTree = renderComponentRoot(instance); 14529 if (true) { 14530 endMeasure(instance, `render`); 14531 } 14532 const prevTree = instance.subTree; 14533 instance.subTree = nextTree; 14534 if (true) { 14535 startMeasure(instance, `patch`); 14536 } 14537 patch( 14538 prevTree, 14539 nextTree, 14540 // parent may have changed if it's in a teleport 14541 hostParentNode(prevTree.el), 14542 // anchor may have changed if it's in a fragment 14543 getNextHostNode(prevTree), 14544 instance, 14545 parentSuspense, 14546 namespace 14547 ); 14548 if (true) { 14549 endMeasure(instance, `patch`); 14550 } 14551 next.el = nextTree.el; 14552 if (originNext === null) { 14553 updateHOCHostEl(instance, nextTree.el); 14554 } 14555 if (u) { 14556 queuePostRenderEffect(u, parentSuspense); 14557 } 14558 if (vnodeHook = next.props && next.props.onVnodeUpdated) { 14559 queuePostRenderEffect( 14560 () => invokeVNodeHook(vnodeHook, parent, next, vnode), 14561 parentSuspense 14562 ); 14563 } 14564 if (true) { 14565 devtoolsComponentUpdated(instance); 14566 } 14567 if (true) { 14568 popWarningContext(); 14569 } 14570 } 14571 }; 14572 instance.scope.on(); 14573 const effect = instance.effect = new _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect(componentUpdateFn); 14574 instance.scope.off(); 14575 const update = instance.update = effect.run.bind(effect); 14576 const job = instance.job = effect.runIfDirty.bind(effect); 14577 job.i = instance; 14578 job.id = instance.uid; 14579 effect.scheduler = () => queueJob(job); 14580 toggleRecurse(instance, true); 14581 if (true) { 14582 effect.onTrack = instance.rtc ? (e) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance.rtc, e) : void 0; 14583 effect.onTrigger = instance.rtg ? (e) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance.rtg, e) : void 0; 14584 } 14585 update(); 14586 }; 14587 const updateComponentPreRender = (instance, nextVNode, optimized) => { 14588 nextVNode.component = instance; 14589 const prevProps = instance.vnode.props; 14590 instance.vnode = nextVNode; 14591 instance.next = null; 14592 updateProps(instance, nextVNode.props, prevProps, optimized); 14593 updateSlots(instance, nextVNode.children, optimized); 14594 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 14595 flushPreFlushCbs(instance); 14596 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 14597 }; 14598 const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => { 14599 const c1 = n1 && n1.children; 14600 const prevShapeFlag = n1 ? n1.shapeFlag : 0; 14601 const c2 = n2.children; 14602 const { patchFlag, shapeFlag } = n2; 14603 if (patchFlag > 0) { 14604 if (patchFlag & 128) { 14605 patchKeyedChildren( 14606 c1, 14607 c2, 14608 container, 14609 anchor, 14610 parentComponent, 14611 parentSuspense, 14612 namespace, 14613 slotScopeIds, 14614 optimized 14615 ); 14616 return; 14617 } else if (patchFlag & 256) { 14618 patchUnkeyedChildren( 14619 c1, 14620 c2, 14621 container, 14622 anchor, 14623 parentComponent, 14624 parentSuspense, 14625 namespace, 14626 slotScopeIds, 14627 optimized 14628 ); 14629 return; 14630 } 14631 } 14632 if (shapeFlag & 8) { 14633 if (prevShapeFlag & 16) { 14634 unmountChildren(c1, parentComponent, parentSuspense); 14635 } 14636 if (c2 !== c1) { 14637 hostSetElementText(container, c2); 14638 } 14639 } else { 14640 if (prevShapeFlag & 16) { 14641 if (shapeFlag & 16) { 14642 patchKeyedChildren( 14643 c1, 14644 c2, 14645 container, 14646 anchor, 14647 parentComponent, 14648 parentSuspense, 14649 namespace, 14650 slotScopeIds, 14651 optimized 14652 ); 14653 } else { 14654 unmountChildren(c1, parentComponent, parentSuspense, true); 14655 } 14656 } else { 14657 if (prevShapeFlag & 8) { 14658 hostSetElementText(container, ""); 14659 } 14660 if (shapeFlag & 16) { 14661 mountChildren( 14662 c2, 14663 container, 14664 anchor, 14665 parentComponent, 14666 parentSuspense, 14667 namespace, 14668 slotScopeIds, 14669 optimized 14670 ); 14671 } 14672 } 14673 } 14674 }; 14675 const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => { 14676 c1 = c1 || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR; 14677 c2 = c2 || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR; 14678 const oldLength = c1.length; 14679 const newLength = c2.length; 14680 const commonLength = Math.min(oldLength, newLength); 14681 let i; 14682 for (i = 0; i < commonLength; i++) { 14683 const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]); 14684 patch( 14685 c1[i], 14686 nextChild, 14687 container, 14688 null, 14689 parentComponent, 14690 parentSuspense, 14691 namespace, 14692 slotScopeIds, 14693 optimized 14694 ); 14695 } 14696 if (oldLength > newLength) { 14697 unmountChildren( 14698 c1, 14699 parentComponent, 14700 parentSuspense, 14701 true, 14702 false, 14703 commonLength 14704 ); 14705 } else { 14706 mountChildren( 14707 c2, 14708 container, 14709 anchor, 14710 parentComponent, 14711 parentSuspense, 14712 namespace, 14713 slotScopeIds, 14714 optimized, 14715 commonLength 14716 ); 14717 } 14718 }; 14719 const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => { 14720 let i = 0; 14721 const l2 = c2.length; 14722 let e1 = c1.length - 1; 14723 let e2 = l2 - 1; 14724 while (i <= e1 && i <= e2) { 14725 const n1 = c1[i]; 14726 const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]); 14727 if (isSameVNodeType(n1, n2)) { 14728 patch( 14729 n1, 14730 n2, 14731 container, 14732 null, 14733 parentComponent, 14734 parentSuspense, 14735 namespace, 14736 slotScopeIds, 14737 optimized 14738 ); 14739 } else { 14740 break; 14741 } 14742 i++; 14743 } 14744 while (i <= e1 && i <= e2) { 14745 const n1 = c1[e1]; 14746 const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]); 14747 if (isSameVNodeType(n1, n2)) { 14748 patch( 14749 n1, 14750 n2, 14751 container, 14752 null, 14753 parentComponent, 14754 parentSuspense, 14755 namespace, 14756 slotScopeIds, 14757 optimized 14758 ); 14759 } else { 14760 break; 14761 } 14762 e1--; 14763 e2--; 14764 } 14765 if (i > e1) { 14766 if (i <= e2) { 14767 const nextPos = e2 + 1; 14768 const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor; 14769 while (i <= e2) { 14770 patch( 14771 null, 14772 c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]), 14773 container, 14774 anchor, 14775 parentComponent, 14776 parentSuspense, 14777 namespace, 14778 slotScopeIds, 14779 optimized 14780 ); 14781 i++; 14782 } 14783 } 14784 } else if (i > e2) { 14785 while (i <= e1) { 14786 unmount(c1[i], parentComponent, parentSuspense, true); 14787 i++; 14788 } 14789 } else { 14790 const s1 = i; 14791 const s2 = i; 14792 const keyToNewIndexMap = /* @__PURE__ */ new Map(); 14793 for (i = s2; i <= e2; i++) { 14794 const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]); 14795 if (nextChild.key != null) { 14796 if ( true && keyToNewIndexMap.has(nextChild.key)) { 14797 warn$1( 14798 `Duplicate keys found during update:`, 14799 JSON.stringify(nextChild.key), 14800 `Make sure keys are unique.` 14801 ); 14802 } 14803 keyToNewIndexMap.set(nextChild.key, i); 14804 } 14805 } 14806 let j; 14807 let patched = 0; 14808 const toBePatched = e2 - s2 + 1; 14809 let moved = false; 14810 let maxNewIndexSoFar = 0; 14811 const newIndexToOldIndexMap = new Array(toBePatched); 14812 for (i = 0; i < toBePatched; i++) newIndexToOldIndexMap[i] = 0; 14813 for (i = s1; i <= e1; i++) { 14814 const prevChild = c1[i]; 14815 if (patched >= toBePatched) { 14816 unmount(prevChild, parentComponent, parentSuspense, true); 14817 continue; 14818 } 14819 let newIndex; 14820 if (prevChild.key != null) { 14821 newIndex = keyToNewIndexMap.get(prevChild.key); 14822 } else { 14823 for (j = s2; j <= e2; j++) { 14824 if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) { 14825 newIndex = j; 14826 break; 14827 } 14828 } 14829 } 14830 if (newIndex === void 0) { 14831 unmount(prevChild, parentComponent, parentSuspense, true); 14832 } else { 14833 newIndexToOldIndexMap[newIndex - s2] = i + 1; 14834 if (newIndex >= maxNewIndexSoFar) { 14835 maxNewIndexSoFar = newIndex; 14836 } else { 14837 moved = true; 14838 } 14839 patch( 14840 prevChild, 14841 c2[newIndex], 14842 container, 14843 null, 14844 parentComponent, 14845 parentSuspense, 14846 namespace, 14847 slotScopeIds, 14848 optimized 14849 ); 14850 patched++; 14851 } 14852 } 14853 const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR; 14854 j = increasingNewIndexSequence.length - 1; 14855 for (i = toBePatched - 1; i >= 0; i--) { 14856 const nextIndex = s2 + i; 14857 const nextChild = c2[nextIndex]; 14858 const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor; 14859 if (newIndexToOldIndexMap[i] === 0) { 14860 patch( 14861 null, 14862 nextChild, 14863 container, 14864 anchor, 14865 parentComponent, 14866 parentSuspense, 14867 namespace, 14868 slotScopeIds, 14869 optimized 14870 ); 14871 } else if (moved) { 14872 if (j < 0 || i !== increasingNewIndexSequence[j]) { 14873 move(nextChild, container, anchor, 2); 14874 } else { 14875 j--; 14876 } 14877 } 14878 } 14879 } 14880 }; 14881 const move = (vnode, container, anchor, moveType, parentSuspense = null) => { 14882 const { el, type, transition, children, shapeFlag } = vnode; 14883 if (shapeFlag & 6) { 14884 move(vnode.component.subTree, container, anchor, moveType); 14885 return; 14886 } 14887 if (shapeFlag & 128) { 14888 vnode.suspense.move(container, anchor, moveType); 14889 return; 14890 } 14891 if (shapeFlag & 64) { 14892 type.move(vnode, container, anchor, internals); 14893 return; 14894 } 14895 if (type === Fragment) { 14896 hostInsert(el, container, anchor); 14897 for (let i = 0; i < children.length; i++) { 14898 move(children[i], container, anchor, moveType); 14899 } 14900 hostInsert(vnode.anchor, container, anchor); 14901 return; 14902 } 14903 if (type === Static) { 14904 moveStaticNode(vnode, container, anchor); 14905 return; 14906 } 14907 const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition; 14908 if (needTransition2) { 14909 if (moveType === 0) { 14910 transition.beforeEnter(el); 14911 hostInsert(el, container, anchor); 14912 queuePostRenderEffect(() => transition.enter(el), parentSuspense); 14913 } else { 14914 const { leave, delayLeave, afterLeave } = transition; 14915 const remove2 = () => hostInsert(el, container, anchor); 14916 const performLeave = () => { 14917 leave(el, () => { 14918 remove2(); 14919 afterLeave && afterLeave(); 14920 }); 14921 }; 14922 if (delayLeave) { 14923 delayLeave(el, remove2, performLeave); 14924 } else { 14925 performLeave(); 14926 } 14927 } 14928 } else { 14929 hostInsert(el, container, anchor); 14930 } 14931 }; 14932 const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => { 14933 const { 14934 type, 14935 props, 14936 ref, 14937 children, 14938 dynamicChildren, 14939 shapeFlag, 14940 patchFlag, 14941 dirs, 14942 cacheIndex 14943 } = vnode; 14944 if (patchFlag === -2) { 14945 optimized = false; 14946 } 14947 if (ref != null) { 14948 setRef(ref, null, parentSuspense, vnode, true); 14949 } 14950 if (cacheIndex != null) { 14951 parentComponent.renderCache[cacheIndex] = void 0; 14952 } 14953 if (shapeFlag & 256) { 14954 parentComponent.ctx.deactivate(vnode); 14955 return; 14956 } 14957 const shouldInvokeDirs = shapeFlag & 1 && dirs; 14958 const shouldInvokeVnodeHook = !isAsyncWrapper(vnode); 14959 let vnodeHook; 14960 if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) { 14961 invokeVNodeHook(vnodeHook, parentComponent, vnode); 14962 } 14963 if (shapeFlag & 6) { 14964 unmountComponent(vnode.component, parentSuspense, doRemove); 14965 } else { 14966 if (shapeFlag & 128) { 14967 vnode.suspense.unmount(parentSuspense, doRemove); 14968 return; 14969 } 14970 if (shouldInvokeDirs) { 14971 invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount"); 14972 } 14973 if (shapeFlag & 64) { 14974 vnode.type.remove( 14975 vnode, 14976 parentComponent, 14977 parentSuspense, 14978 internals, 14979 doRemove 14980 ); 14981 } else if (dynamicChildren && // #5154 14982 // when v-once is used inside a block, setBlockTracking(-1) marks the 14983 // parent block with hasOnce: true 14984 // so that it doesn't take the fast path during unmount - otherwise 14985 // components nested in v-once are never unmounted. 14986 !dynamicChildren.hasOnce && // #1153: fast path should not be taken for non-stable (v-for) fragments 14987 (type !== Fragment || patchFlag > 0 && patchFlag & 64)) { 14988 unmountChildren( 14989 dynamicChildren, 14990 parentComponent, 14991 parentSuspense, 14992 false, 14993 true 14994 ); 14995 } else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) { 14996 unmountChildren(children, parentComponent, parentSuspense); 14997 } 14998 if (doRemove) { 14999 remove(vnode); 15000 } 15001 } 15002 if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) { 15003 queuePostRenderEffect(() => { 15004 vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode); 15005 shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted"); 15006 }, parentSuspense); 15007 } 15008 }; 15009 const remove = (vnode) => { 15010 const { type, el, anchor, transition } = vnode; 15011 if (type === Fragment) { 15012 if ( true && vnode.patchFlag > 0 && vnode.patchFlag & 2048 && transition && !transition.persisted) { 15013 vnode.children.forEach((child) => { 15014 if (child.type === Comment) { 15015 hostRemove(child.el); 15016 } else { 15017 remove(child); 15018 } 15019 }); 15020 } else { 15021 removeFragment(el, anchor); 15022 } 15023 return; 15024 } 15025 if (type === Static) { 15026 removeStaticNode(vnode); 15027 return; 15028 } 15029 const performRemove = () => { 15030 hostRemove(el); 15031 if (transition && !transition.persisted && transition.afterLeave) { 15032 transition.afterLeave(); 15033 } 15034 }; 15035 if (vnode.shapeFlag & 1 && transition && !transition.persisted) { 15036 const { leave, delayLeave } = transition; 15037 const performLeave = () => leave(el, performRemove); 15038 if (delayLeave) { 15039 delayLeave(vnode.el, performRemove, performLeave); 15040 } else { 15041 performLeave(); 15042 } 15043 } else { 15044 performRemove(); 15045 } 15046 }; 15047 const removeFragment = (cur, end) => { 15048 let next; 15049 while (cur !== end) { 15050 next = hostNextSibling(cur); 15051 hostRemove(cur); 15052 cur = next; 15053 } 15054 hostRemove(end); 15055 }; 15056 const unmountComponent = (instance, parentSuspense, doRemove) => { 15057 if ( true && instance.type.__hmrId) { 15058 unregisterHMR(instance); 15059 } 15060 const { bum, scope, job, subTree, um, m, a } = instance; 15061 invalidateMount(m); 15062 invalidateMount(a); 15063 if (bum) { 15064 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(bum); 15065 } 15066 scope.stop(); 15067 if (job) { 15068 job.flags |= 8; 15069 unmount(subTree, instance, parentSuspense, doRemove); 15070 } 15071 if (um) { 15072 queuePostRenderEffect(um, parentSuspense); 15073 } 15074 queuePostRenderEffect(() => { 15075 instance.isUnmounted = true; 15076 }, parentSuspense); 15077 if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) { 15078 parentSuspense.deps--; 15079 if (parentSuspense.deps === 0) { 15080 parentSuspense.resolve(); 15081 } 15082 } 15083 if (true) { 15084 devtoolsComponentRemoved(instance); 15085 } 15086 }; 15087 const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => { 15088 for (let i = start; i < children.length; i++) { 15089 unmount(children[i], parentComponent, parentSuspense, doRemove, optimized); 15090 } 15091 }; 15092 const getNextHostNode = (vnode) => { 15093 if (vnode.shapeFlag & 6) { 15094 return getNextHostNode(vnode.component.subTree); 15095 } 15096 if (vnode.shapeFlag & 128) { 15097 return vnode.suspense.next(); 15098 } 15099 const el = hostNextSibling(vnode.anchor || vnode.el); 15100 const teleportEnd = el && el[TeleportEndKey]; 15101 return teleportEnd ? hostNextSibling(teleportEnd) : el; 15102 }; 15103 let isFlushing = false; 15104 const render = (vnode, container, namespace) => { 15105 if (vnode == null) { 15106 if (container._vnode) { 15107 unmount(container._vnode, null, null, true); 15108 } 15109 } else { 15110 patch( 15111 container._vnode || null, 15112 vnode, 15113 container, 15114 null, 15115 null, 15116 null, 15117 namespace 15118 ); 15119 } 15120 container._vnode = vnode; 15121 if (!isFlushing) { 15122 isFlushing = true; 15123 flushPreFlushCbs(); 15124 flushPostFlushCbs(); 15125 isFlushing = false; 15126 } 15127 }; 15128 const internals = { 15129 p: patch, 15130 um: unmount, 15131 m: move, 15132 r: remove, 15133 mt: mountComponent, 15134 mc: mountChildren, 15135 pc: patchChildren, 15136 pbc: patchBlockChildren, 15137 n: getNextHostNode, 15138 o: options 15139 }; 15140 let hydrate; 15141 let hydrateNode; 15142 if (createHydrationFns) { 15143 [hydrate, hydrateNode] = createHydrationFns( 15144 internals 15145 ); 15146 } 15147 return { 15148 render, 15149 hydrate, 15150 createApp: createAppAPI(render, hydrate) 15151 }; 15152} 15153function resolveChildrenNamespace({ type, props }, currentNamespace) { 15154 return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace; 15155} 15156function toggleRecurse({ effect, job }, allowed) { 15157 if (allowed) { 15158 effect.flags |= 32; 15159 job.flags |= 4; 15160 } else { 15161 effect.flags &= ~32; 15162 job.flags &= ~4; 15163 } 15164} 15165function needTransition(parentSuspense, transition) { 15166 return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted; 15167} 15168function traverseStaticChildren(n1, n2, shallow = false) { 15169 const ch1 = n1.children; 15170 const ch2 = n2.children; 15171 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(ch1) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(ch2)) { 15172 for (let i = 0; i < ch1.length; i++) { 15173 const c1 = ch1[i]; 15174 let c2 = ch2[i]; 15175 if (c2.shapeFlag & 1 && !c2.dynamicChildren) { 15176 if (c2.patchFlag <= 0 || c2.patchFlag === 32) { 15177 c2 = ch2[i] = cloneIfMounted(ch2[i]); 15178 c2.el = c1.el; 15179 } 15180 if (!shallow && c2.patchFlag !== -2) 15181 traverseStaticChildren(c1, c2); 15182 } 15183 if (c2.type === Text) { 15184 c2.el = c1.el; 15185 } 15186 if ( true && c2.type === Comment && !c2.el) { 15187 c2.el = c1.el; 15188 } 15189 } 15190 } 15191} 15192function getSequence(arr) { 15193 const p = arr.slice(); 15194 const result = [0]; 15195 let i, j, u, v, c; 15196 const len = arr.length; 15197 for (i = 0; i < len; i++) { 15198 const arrI = arr[i]; 15199 if (arrI !== 0) { 15200 j = result[result.length - 1]; 15201 if (arr[j] < arrI) { 15202 p[i] = j; 15203 result.push(i); 15204 continue; 15205 } 15206 u = 0; 15207 v = result.length - 1; 15208 while (u < v) { 15209 c = u + v >> 1; 15210 if (arr[result[c]] < arrI) { 15211 u = c + 1; 15212 } else { 15213 v = c; 15214 } 15215 } 15216 if (arrI < arr[result[u]]) { 15217 if (u > 0) { 15218 p[i] = result[u - 1]; 15219 } 15220 result[u] = i; 15221 } 15222 } 15223 } 15224 u = result.length; 15225 v = result[u - 1]; 15226 while (u-- > 0) { 15227 result[u] = v; 15228 v = p[v]; 15229 } 15230 return result; 15231} 15232function locateNonHydratedAsyncRoot(instance) { 15233 const subComponent = instance.subTree.component; 15234 if (subComponent) { 15235 if (subComponent.asyncDep && !subComponent.asyncResolved) { 15236 return subComponent; 15237 } else { 15238 return locateNonHydratedAsyncRoot(subComponent); 15239 } 15240 } 15241} 15242function invalidateMount(hooks) { 15243 if (hooks) { 15244 for (let i = 0; i < hooks.length; i++) 15245 hooks[i].flags |= 8; 15246 } 15247} 15248 15249const ssrContextKey = Symbol.for("v-scx"); 15250const useSSRContext = () => { 15251 { 15252 const ctx = inject(ssrContextKey); 15253 if (!ctx) { 15254 true && warn$1( 15255 `Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.` 15256 ); 15257 } 15258 return ctx; 15259 } 15260}; 15261 15262function watchEffect(effect, options) { 15263 return doWatch(effect, null, options); 15264} 15265function watchPostEffect(effect, options) { 15266 return doWatch( 15267 effect, 15268 null, 15269 true ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, options, { flush: "post" }) : 0 15270 ); 15271} 15272function watchSyncEffect(effect, options) { 15273 return doWatch( 15274 effect, 15275 null, 15276 true ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, options, { flush: "sync" }) : 0 15277 ); 15278} 15279function watch(source, cb, options) { 15280 if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(cb)) { 15281 warn$1( 15282 `\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.` 15283 ); 15284 } 15285 return doWatch(source, cb, options); 15286} 15287function doWatch(source, cb, options = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) { 15288 const { immediate, deep, flush, once } = options; 15289 if ( true && !cb) { 15290 if (immediate !== void 0) { 15291 warn$1( 15292 `watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.` 15293 ); 15294 } 15295 if (deep !== void 0) { 15296 warn$1( 15297 `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.` 15298 ); 15299 } 15300 if (once !== void 0) { 15301 warn$1( 15302 `watch() "once" option is only respected when using the watch(source, callback, options?) signature.` 15303 ); 15304 } 15305 } 15306 const baseWatchOptions = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, options); 15307 if (true) baseWatchOptions.onWarn = warn$1; 15308 const runsImmediately = cb && immediate || !cb && flush !== "post"; 15309 let ssrCleanup; 15310 if (isInSSRComponentSetup) { 15311 if (flush === "sync") { 15312 const ctx = useSSRContext(); 15313 ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []); 15314 } else if (!runsImmediately) { 15315 const watchStopHandle = () => { 15316 }; 15317 watchStopHandle.stop = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP; 15318 watchStopHandle.resume = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP; 15319 watchStopHandle.pause = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP; 15320 return watchStopHandle; 15321 } 15322 } 15323 const instance = currentInstance; 15324 baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args); 15325 let isPre = false; 15326 if (flush === "post") { 15327 baseWatchOptions.scheduler = (job) => { 15328 queuePostRenderEffect(job, instance && instance.suspense); 15329 }; 15330 } else if (flush !== "sync") { 15331 isPre = true; 15332 baseWatchOptions.scheduler = (job, isFirstRun) => { 15333 if (isFirstRun) { 15334 job(); 15335 } else { 15336 queueJob(job); 15337 } 15338 }; 15339 } 15340 baseWatchOptions.augmentJob = (job) => { 15341 if (cb) { 15342 job.flags |= 4; 15343 } 15344 if (isPre) { 15345 job.flags |= 2; 15346 if (instance) { 15347 job.id = instance.uid; 15348 job.i = instance; 15349 } 15350 } 15351 }; 15352 const watchHandle = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.watch)(source, cb, baseWatchOptions); 15353 if (isInSSRComponentSetup) { 15354 if (ssrCleanup) { 15355 ssrCleanup.push(watchHandle); 15356 } else if (runsImmediately) { 15357 watchHandle(); 15358 } 15359 } 15360 return watchHandle; 15361} 15362function instanceWatch(source, value, options) { 15363 const publicThis = this.proxy; 15364 const getter = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis); 15365 let cb; 15366 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) { 15367 cb = value; 15368 } else { 15369 cb = value.handler; 15370 options = value; 15371 } 15372 const reset = setCurrentInstance(this); 15373 const res = doWatch(getter, cb.bind(publicThis), options); 15374 reset(); 15375 return res; 15376} 15377function createPathGetter(ctx, path) { 15378 const segments = path.split("."); 15379 return () => { 15380 let cur = ctx; 15381 for (let i = 0; i < segments.length && cur; i++) { 15382 cur = cur[segments[i]]; 15383 } 15384 return cur; 15385 }; 15386} 15387 15388function useModel(props, name, options = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) { 15389 const i = getCurrentInstance(); 15390 if ( true && !i) { 15391 warn$1(`useModel() called without active instance.`); 15392 return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)(); 15393 } 15394 const camelizedName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name); 15395 if ( true && !i.propsOptions[0][camelizedName]) { 15396 warn$1(`useModel() called with prop "${name}" which is not declared.`); 15397 return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)(); 15398 } 15399 const hyphenatedName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(name); 15400 const modifiers = getModelModifiers(props, camelizedName); 15401 const res = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.customRef)((track, trigger) => { 15402 let localValue; 15403 let prevSetValue = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 15404 let prevEmittedValue; 15405 watchSyncEffect(() => { 15406 const propValue = props[camelizedName]; 15407 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(localValue, propValue)) { 15408 localValue = propValue; 15409 trigger(); 15410 } 15411 }); 15412 return { 15413 get() { 15414 track(); 15415 return options.get ? options.get(localValue) : localValue; 15416 }, 15417 set(value) { 15418 const emittedValue = options.set ? options.set(value) : value; 15419 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(emittedValue, localValue) && !(prevSetValue !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(value, prevSetValue))) { 15420 return; 15421 } 15422 const rawProps = i.vnode.props; 15423 if (!(rawProps && // check if parent has passed v-model 15424 (name in rawProps || camelizedName in rawProps || hyphenatedName in rawProps) && (`onUpdate:${name}` in rawProps || `onUpdate:${camelizedName}` in rawProps || `onUpdate:${hyphenatedName}` in rawProps))) { 15425 localValue = value; 15426 trigger(); 15427 } 15428 i.emit(`update:${name}`, emittedValue); 15429 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(value, emittedValue) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(value, prevSetValue) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(emittedValue, prevEmittedValue)) { 15430 trigger(); 15431 } 15432 prevSetValue = value; 15433 prevEmittedValue = emittedValue; 15434 } 15435 }; 15436 }); 15437 res[Symbol.iterator] = () => { 15438 let i2 = 0; 15439 return { 15440 next() { 15441 if (i2 < 2) { 15442 return { value: i2++ ? modifiers || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ : res, done: false }; 15443 } else { 15444 return { done: true }; 15445 } 15446 } 15447 }; 15448 }; 15449 return res; 15450} 15451const getModelModifiers = (props, modelName) => { 15452 return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(modelName)}Modifiers`] || props[`${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(modelName)}Modifiers`]; 15453}; 15454 15455function emit(instance, event, ...rawArgs) { 15456 if (instance.isUnmounted) return; 15457 const props = instance.vnode.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 15458 if (true) { 15459 const { 15460 emitsOptions, 15461 propsOptions: [propsOptions] 15462 } = instance; 15463 if (emitsOptions) { 15464 if (!(event in emitsOptions) && true) { 15465 if (!propsOptions || !((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(event)) in propsOptions)) { 15466 warn$1( 15467 `Component emitted event "${event}" but it is neither declared in the emits option nor as an "${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(event))}" prop.` 15468 ); 15469 } 15470 } else { 15471 const validator = emitsOptions[event]; 15472 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(validator)) { 15473 const isValid = validator(...rawArgs); 15474 if (!isValid) { 15475 warn$1( 15476 `Invalid event arguments: event validation failed for event "${event}".` 15477 ); 15478 } 15479 } 15480 } 15481 } 15482 } 15483 let args = rawArgs; 15484 const isModelListener = event.startsWith("update:"); 15485 const modifiers = isModelListener && getModelModifiers(props, event.slice(7)); 15486 if (modifiers) { 15487 if (modifiers.trim) { 15488 args = rawArgs.map((a) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(a) ? a.trim() : a); 15489 } 15490 if (modifiers.number) { 15491 args = rawArgs.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseToNumber); 15492 } 15493 } 15494 if (true) { 15495 devtoolsComponentEmit(instance, event, args); 15496 } 15497 if (true) { 15498 const lowerCaseEvent = event.toLowerCase(); 15499 if (lowerCaseEvent !== event && props[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(lowerCaseEvent)]) { 15500 warn$1( 15501 `Event "${lowerCaseEvent}" is emitted in component ${formatComponentName( 15502 instance, 15503 instance.type 15504 )} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)( 15505 event 15506 )}" instead of "${event}".` 15507 ); 15508 } 15509 } 15510 let handlerName; 15511 let handler = props[handlerName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(event)] || // also try camelCase event handler (#2249) 15512 props[handlerName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(event))]; 15513 if (!handler && isModelListener) { 15514 handler = props[handlerName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event))]; 15515 } 15516 if (handler) { 15517 callWithAsyncErrorHandling( 15518 handler, 15519 instance, 15520 6, 15521 args 15522 ); 15523 } 15524 const onceHandler = props[handlerName + `Once`]; 15525 if (onceHandler) { 15526 if (!instance.emitted) { 15527 instance.emitted = {}; 15528 } else if (instance.emitted[handlerName]) { 15529 return; 15530 } 15531 instance.emitted[handlerName] = true; 15532 callWithAsyncErrorHandling( 15533 onceHandler, 15534 instance, 15535 6, 15536 args 15537 ); 15538 } 15539} 15540function normalizeEmitsOptions(comp, appContext, asMixin = false) { 15541 const cache = appContext.emitsCache; 15542 const cached = cache.get(comp); 15543 if (cached !== void 0) { 15544 return cached; 15545 } 15546 const raw = comp.emits; 15547 let normalized = {}; 15548 let hasExtends = false; 15549 if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(comp)) { 15550 const extendEmits = (raw2) => { 15551 const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true); 15552 if (normalizedFromExtend) { 15553 hasExtends = true; 15554 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(normalized, normalizedFromExtend); 15555 } 15556 }; 15557 if (!asMixin && appContext.mixins.length) { 15558 appContext.mixins.forEach(extendEmits); 15559 } 15560 if (comp.extends) { 15561 extendEmits(comp.extends); 15562 } 15563 if (comp.mixins) { 15564 comp.mixins.forEach(extendEmits); 15565 } 15566 } 15567 if (!raw && !hasExtends) { 15568 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) { 15569 cache.set(comp, null); 15570 } 15571 return null; 15572 } 15573 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) { 15574 raw.forEach((key) => normalized[key] = null); 15575 } else { 15576 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(normalized, raw); 15577 } 15578 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) { 15579 cache.set(comp, normalized); 15580 } 15581 return normalized; 15582} 15583function isEmitListener(options, key) { 15584 if (!options || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) { 15585 return false; 15586 } 15587 key = key.slice(2).replace(/Once$/, ""); 15588 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, key[0].toLowerCase() + key.slice(1)) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key)) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, key); 15589} 15590 15591let accessedAttrs = false; 15592function markAttrsAccessed() { 15593 accessedAttrs = true; 15594} 15595function renderComponentRoot(instance) { 15596 const { 15597 type: Component, 15598 vnode, 15599 proxy, 15600 withProxy, 15601 propsOptions: [propsOptions], 15602 slots, 15603 attrs, 15604 emit, 15605 render, 15606 renderCache, 15607 props, 15608 data, 15609 setupState, 15610 ctx, 15611 inheritAttrs 15612 } = instance; 15613 const prev = setCurrentRenderingInstance(instance); 15614 let result; 15615 let fallthroughAttrs; 15616 if (true) { 15617 accessedAttrs = false; 15618 } 15619 try { 15620 if (vnode.shapeFlag & 4) { 15621 const proxyToUse = withProxy || proxy; 15622 const thisProxy = true && setupState.__isScriptSetup ? new Proxy(proxyToUse, { 15623 get(target, key, receiver) { 15624 warn$1( 15625 `Property '${String( 15626 key 15627 )}' was accessed via 'this'. Avoid using 'this' in templates.` 15628 ); 15629 return Reflect.get(target, key, receiver); 15630 } 15631 }) : proxyToUse; 15632 result = normalizeVNode( 15633 render.call( 15634 thisProxy, 15635 proxyToUse, 15636 renderCache, 15637 true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(props) : 0, 15638 setupState, 15639 data, 15640 ctx 15641 ) 15642 ); 15643 fallthroughAttrs = attrs; 15644 } else { 15645 const render2 = Component; 15646 if ( true && attrs === props) { 15647 markAttrsAccessed(); 15648 } 15649 result = normalizeVNode( 15650 render2.length > 1 ? render2( 15651 true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(props) : 0, 15652 true ? { 15653 get attrs() { 15654 markAttrsAccessed(); 15655 return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(attrs); 15656 }, 15657 slots, 15658 emit 15659 } : 0 15660 ) : render2( 15661 true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(props) : 0, 15662 null 15663 ) 15664 ); 15665 fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs); 15666 } 15667 } catch (err) { 15668 blockStack.length = 0; 15669 handleError(err, instance, 1); 15670 result = createVNode(Comment); 15671 } 15672 let root = result; 15673 let setRoot = void 0; 15674 if ( true && result.patchFlag > 0 && result.patchFlag & 2048) { 15675 [root, setRoot] = getChildRoot(result); 15676 } 15677 if (fallthroughAttrs && inheritAttrs !== false) { 15678 const keys = Object.keys(fallthroughAttrs); 15679 const { shapeFlag } = root; 15680 if (keys.length) { 15681 if (shapeFlag & (1 | 6)) { 15682 if (propsOptions && keys.some(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)) { 15683 fallthroughAttrs = filterModelListeners( 15684 fallthroughAttrs, 15685 propsOptions 15686 ); 15687 } 15688 root = cloneVNode(root, fallthroughAttrs, false, true); 15689 } else if ( true && !accessedAttrs && root.type !== Comment) { 15690 const allAttrs = Object.keys(attrs); 15691 const eventAttrs = []; 15692 const extraAttrs = []; 15693 for (let i = 0, l = allAttrs.length; i < l; i++) { 15694 const key = allAttrs[i]; 15695 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) { 15696 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)(key)) { 15697 eventAttrs.push(key[2].toLowerCase() + key.slice(3)); 15698 } 15699 } else { 15700 extraAttrs.push(key); 15701 } 15702 } 15703 if (extraAttrs.length) { 15704 warn$1( 15705 `Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text or teleport root nodes.` 15706 ); 15707 } 15708 if (eventAttrs.length) { 15709 warn$1( 15710 `Extraneous non-emits event listeners (${eventAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.` 15711 ); 15712 } 15713 } 15714 } 15715 } 15716 if (vnode.dirs) { 15717 if ( true && !isElementRoot(root)) { 15718 warn$1( 15719 `Runtime directive used on component with non-element root node. The directives will not function as intended.` 15720 ); 15721 } 15722 root = cloneVNode(root, null, false, true); 15723 root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs; 15724 } 15725 if (vnode.transition) { 15726 if ( true && !isElementRoot(root)) { 15727 warn$1( 15728 `Component inside <Transition> renders non-element root node that cannot be animated.` 15729 ); 15730 } 15731 setTransitionHooks(root, vnode.transition); 15732 } 15733 if ( true && setRoot) { 15734 setRoot(root); 15735 } else { 15736 result = root; 15737 } 15738 setCurrentRenderingInstance(prev); 15739 return result; 15740} 15741const getChildRoot = (vnode) => { 15742 const rawChildren = vnode.children; 15743 const dynamicChildren = vnode.dynamicChildren; 15744 const childRoot = filterSingleRoot(rawChildren, false); 15745 if (!childRoot) { 15746 return [vnode, void 0]; 15747 } else if ( true && childRoot.patchFlag > 0 && childRoot.patchFlag & 2048) { 15748 return getChildRoot(childRoot); 15749 } 15750 const index = rawChildren.indexOf(childRoot); 15751 const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1; 15752 const setRoot = (updatedRoot) => { 15753 rawChildren[index] = updatedRoot; 15754 if (dynamicChildren) { 15755 if (dynamicIndex > -1) { 15756 dynamicChildren[dynamicIndex] = updatedRoot; 15757 } else if (updatedRoot.patchFlag > 0) { 15758 vnode.dynamicChildren = [...dynamicChildren, updatedRoot]; 15759 } 15760 } 15761 }; 15762 return [normalizeVNode(childRoot), setRoot]; 15763}; 15764function filterSingleRoot(children, recurse = true) { 15765 let singleRoot; 15766 for (let i = 0; i < children.length; i++) { 15767 const child = children[i]; 15768 if (isVNode(child)) { 15769 if (child.type !== Comment || child.children === "v-if") { 15770 if (singleRoot) { 15771 return; 15772 } else { 15773 singleRoot = child; 15774 if ( true && recurse && singleRoot.patchFlag > 0 && singleRoot.patchFlag & 2048) { 15775 return filterSingleRoot(singleRoot.children); 15776 } 15777 } 15778 } 15779 } else { 15780 return; 15781 } 15782 } 15783 return singleRoot; 15784} 15785const getFunctionalFallthrough = (attrs) => { 15786 let res; 15787 for (const key in attrs) { 15788 if (key === "class" || key === "style" || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) { 15789 (res || (res = {}))[key] = attrs[key]; 15790 } 15791 } 15792 return res; 15793}; 15794const filterModelListeners = (attrs, props) => { 15795 const res = {}; 15796 for (const key in attrs) { 15797 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)(key) || !(key.slice(9) in props)) { 15798 res[key] = attrs[key]; 15799 } 15800 } 15801 return res; 15802}; 15803const isElementRoot = (vnode) => { 15804 return vnode.shapeFlag & (6 | 1) || vnode.type === Comment; 15805}; 15806function shouldUpdateComponent(prevVNode, nextVNode, optimized) { 15807 const { props: prevProps, children: prevChildren, component } = prevVNode; 15808 const { props: nextProps, children: nextChildren, patchFlag } = nextVNode; 15809 const emits = component.emitsOptions; 15810 if ( true && (prevChildren || nextChildren) && isHmrUpdating) { 15811 return true; 15812 } 15813 if (nextVNode.dirs || nextVNode.transition) { 15814 return true; 15815 } 15816 if (optimized && patchFlag >= 0) { 15817 if (patchFlag & 1024) { 15818 return true; 15819 } 15820 if (patchFlag & 16) { 15821 if (!prevProps) { 15822 return !!nextProps; 15823 } 15824 return hasPropsChanged(prevProps, nextProps, emits); 15825 } else if (patchFlag & 8) { 15826 const dynamicProps = nextVNode.dynamicProps; 15827 for (let i = 0; i < dynamicProps.length; i++) { 15828 const key = dynamicProps[i]; 15829 if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) { 15830 return true; 15831 } 15832 } 15833 } 15834 } else { 15835 if (prevChildren || nextChildren) { 15836 if (!nextChildren || !nextChildren.$stable) { 15837 return true; 15838 } 15839 } 15840 if (prevProps === nextProps) { 15841 return false; 15842 } 15843 if (!prevProps) { 15844 return !!nextProps; 15845 } 15846 if (!nextProps) { 15847 return true; 15848 } 15849 return hasPropsChanged(prevProps, nextProps, emits); 15850 } 15851 return false; 15852} 15853function hasPropsChanged(prevProps, nextProps, emitsOptions) { 15854 const nextKeys = Object.keys(nextProps); 15855 if (nextKeys.length !== Object.keys(prevProps).length) { 15856 return true; 15857 } 15858 for (let i = 0; i < nextKeys.length; i++) { 15859 const key = nextKeys[i]; 15860 if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) { 15861 return true; 15862 } 15863 } 15864 return false; 15865} 15866function updateHOCHostEl({ vnode, parent }, el) { 15867 while (parent) { 15868 const root = parent.subTree; 15869 if (root.suspense && root.suspense.activeBranch === vnode) { 15870 root.el = vnode.el; 15871 } 15872 if (root === vnode) { 15873 (vnode = parent.vnode).el = el; 15874 parent = parent.parent; 15875 } else { 15876 break; 15877 } 15878 } 15879} 15880 15881const isSuspense = (type) => type.__isSuspense; 15882let suspenseId = 0; 15883const SuspenseImpl = { 15884 name: "Suspense", 15885 // In order to make Suspense tree-shakable, we need to avoid importing it 15886 // directly in the renderer. The renderer checks for the __isSuspense flag 15887 // on a vnode's type and calls the `process` method, passing in renderer 15888 // internals. 15889 __isSuspense: true, 15890 process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) { 15891 if (n1 == null) { 15892 mountSuspense( 15893 n2, 15894 container, 15895 anchor, 15896 parentComponent, 15897 parentSuspense, 15898 namespace, 15899 slotScopeIds, 15900 optimized, 15901 rendererInternals 15902 ); 15903 } else { 15904 if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback) { 15905 n2.suspense = n1.suspense; 15906 n2.suspense.vnode = n2; 15907 n2.el = n1.el; 15908 return; 15909 } 15910 patchSuspense( 15911 n1, 15912 n2, 15913 container, 15914 anchor, 15915 parentComponent, 15916 namespace, 15917 slotScopeIds, 15918 optimized, 15919 rendererInternals 15920 ); 15921 } 15922 }, 15923 hydrate: hydrateSuspense, 15924 normalize: normalizeSuspenseChildren 15925}; 15926const Suspense = SuspenseImpl ; 15927function triggerEvent(vnode, name) { 15928 const eventListener = vnode.props && vnode.props[name]; 15929 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(eventListener)) { 15930 eventListener(); 15931 } 15932} 15933function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) { 15934 const { 15935 p: patch, 15936 o: { createElement } 15937 } = rendererInternals; 15938 const hiddenContainer = createElement("div"); 15939 const suspense = vnode.suspense = createSuspenseBoundary( 15940 vnode, 15941 parentSuspense, 15942 parentComponent, 15943 container, 15944 hiddenContainer, 15945 anchor, 15946 namespace, 15947 slotScopeIds, 15948 optimized, 15949 rendererInternals 15950 ); 15951 patch( 15952 null, 15953 suspense.pendingBranch = vnode.ssContent, 15954 hiddenContainer, 15955 null, 15956 parentComponent, 15957 suspense, 15958 namespace, 15959 slotScopeIds 15960 ); 15961 if (suspense.deps > 0) { 15962 triggerEvent(vnode, "onPending"); 15963 triggerEvent(vnode, "onFallback"); 15964 patch( 15965 null, 15966 vnode.ssFallback, 15967 container, 15968 anchor, 15969 parentComponent, 15970 null, 15971 // fallback tree will not have suspense context 15972 namespace, 15973 slotScopeIds 15974 ); 15975 setActiveBranch(suspense, vnode.ssFallback); 15976 } else { 15977 suspense.resolve(false, true); 15978 } 15979} 15980function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) { 15981 const suspense = n2.suspense = n1.suspense; 15982 suspense.vnode = n2; 15983 n2.el = n1.el; 15984 const newBranch = n2.ssContent; 15985 const newFallback = n2.ssFallback; 15986 const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense; 15987 if (pendingBranch) { 15988 suspense.pendingBranch = newBranch; 15989 if (isSameVNodeType(newBranch, pendingBranch)) { 15990 patch( 15991 pendingBranch, 15992 newBranch, 15993 suspense.hiddenContainer, 15994 null, 15995 parentComponent, 15996 suspense, 15997 namespace, 15998 slotScopeIds, 15999 optimized 16000 ); 16001 if (suspense.deps <= 0) { 16002 suspense.resolve(); 16003 } else if (isInFallback) { 16004 if (!isHydrating) { 16005 patch( 16006 activeBranch, 16007 newFallback, 16008 container, 16009 anchor, 16010 parentComponent, 16011 null, 16012 // fallback tree will not have suspense context 16013 namespace, 16014 slotScopeIds, 16015 optimized 16016 ); 16017 setActiveBranch(suspense, newFallback); 16018 } 16019 } 16020 } else { 16021 suspense.pendingId = suspenseId++; 16022 if (isHydrating) { 16023 suspense.isHydrating = false; 16024 suspense.activeBranch = pendingBranch; 16025 } else { 16026 unmount(pendingBranch, parentComponent, suspense); 16027 } 16028 suspense.deps = 0; 16029 suspense.effects.length = 0; 16030 suspense.hiddenContainer = createElement("div"); 16031 if (isInFallback) { 16032 patch( 16033 null, 16034 newBranch, 16035 suspense.hiddenContainer, 16036 null, 16037 parentComponent, 16038 suspense, 16039 namespace, 16040 slotScopeIds, 16041 optimized 16042 ); 16043 if (suspense.deps <= 0) { 16044 suspense.resolve(); 16045 } else { 16046 patch( 16047 activeBranch, 16048 newFallback, 16049 container, 16050 anchor, 16051 parentComponent, 16052 null, 16053 // fallback tree will not have suspense context 16054 namespace, 16055 slotScopeIds, 16056 optimized 16057 ); 16058 setActiveBranch(suspense, newFallback); 16059 } 16060 } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { 16061 patch( 16062 activeBranch, 16063 newBranch, 16064 container, 16065 anchor, 16066 parentComponent, 16067 suspense, 16068 namespace, 16069 slotScopeIds, 16070 optimized 16071 ); 16072 suspense.resolve(true); 16073 } else { 16074 patch( 16075 null, 16076 newBranch, 16077 suspense.hiddenContainer, 16078 null, 16079 parentComponent, 16080 suspense, 16081 namespace, 16082 slotScopeIds, 16083 optimized 16084 ); 16085 if (suspense.deps <= 0) { 16086 suspense.resolve(); 16087 } 16088 } 16089 } 16090 } else { 16091 if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { 16092 patch( 16093 activeBranch, 16094 newBranch, 16095 container, 16096 anchor, 16097 parentComponent, 16098 suspense, 16099 namespace, 16100 slotScopeIds, 16101 optimized 16102 ); 16103 setActiveBranch(suspense, newBranch); 16104 } else { 16105 triggerEvent(n2, "onPending"); 16106 suspense.pendingBranch = newBranch; 16107 if (newBranch.shapeFlag & 512) { 16108 suspense.pendingId = newBranch.component.suspenseId; 16109 } else { 16110 suspense.pendingId = suspenseId++; 16111 } 16112 patch( 16113 null, 16114 newBranch, 16115 suspense.hiddenContainer, 16116 null, 16117 parentComponent, 16118 suspense, 16119 namespace, 16120 slotScopeIds, 16121 optimized 16122 ); 16123 if (suspense.deps <= 0) { 16124 suspense.resolve(); 16125 } else { 16126 const { timeout, pendingId } = suspense; 16127 if (timeout > 0) { 16128 setTimeout(() => { 16129 if (suspense.pendingId === pendingId) { 16130 suspense.fallback(newFallback); 16131 } 16132 }, timeout); 16133 } else if (timeout === 0) { 16134 suspense.fallback(newFallback); 16135 } 16136 } 16137 } 16138 } 16139} 16140let hasWarned = false; 16141function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, namespace, slotScopeIds, optimized, rendererInternals, isHydrating = false) { 16142 if ( true && !hasWarned) { 16143 hasWarned = true; 16144 console[console.info ? "info" : "log"]( 16145 `<Suspense> is an experimental feature and its API will likely change.` 16146 ); 16147 } 16148 const { 16149 p: patch, 16150 m: move, 16151 um: unmount, 16152 n: next, 16153 o: { parentNode, remove } 16154 } = rendererInternals; 16155 let parentSuspenseId; 16156 const isSuspensible = isVNodeSuspensible(vnode); 16157 if (isSuspensible) { 16158 if (parentSuspense && parentSuspense.pendingBranch) { 16159 parentSuspenseId = parentSuspense.pendingId; 16160 parentSuspense.deps++; 16161 } 16162 } 16163 const timeout = vnode.props ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(vnode.props.timeout) : void 0; 16164 if (true) { 16165 assertNumber(timeout, `Suspense timeout`); 16166 } 16167 const initialAnchor = anchor; 16168 const suspense = { 16169 vnode, 16170 parent: parentSuspense, 16171 parentComponent, 16172 namespace, 16173 container, 16174 hiddenContainer, 16175 deps: 0, 16176 pendingId: suspenseId++, 16177 timeout: typeof timeout === "number" ? timeout : -1, 16178 activeBranch: null, 16179 pendingBranch: null, 16180 isInFallback: !isHydrating, 16181 isHydrating, 16182 isUnmounted: false, 16183 effects: [], 16184 resolve(resume = false, sync = false) { 16185 if (true) { 16186 if (!resume && !suspense.pendingBranch) { 16187 throw new Error( 16188 `suspense.resolve() is called without a pending branch.` 16189 ); 16190 } 16191 if (suspense.isUnmounted) { 16192 throw new Error( 16193 `suspense.resolve() is called on an already unmounted suspense boundary.` 16194 ); 16195 } 16196 } 16197 const { 16198 vnode: vnode2, 16199 activeBranch, 16200 pendingBranch, 16201 pendingId, 16202 effects, 16203 parentComponent: parentComponent2, 16204 container: container2 16205 } = suspense; 16206 let delayEnter = false; 16207 if (suspense.isHydrating) { 16208 suspense.isHydrating = false; 16209 } else if (!resume) { 16210 delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in"; 16211 if (delayEnter) { 16212 activeBranch.transition.afterLeave = () => { 16213 if (pendingId === suspense.pendingId) { 16214 move( 16215 pendingBranch, 16216 container2, 16217 anchor === initialAnchor ? next(activeBranch) : anchor, 16218 0 16219 ); 16220 queuePostFlushCb(effects); 16221 } 16222 }; 16223 } 16224 if (activeBranch) { 16225 if (parentNode(activeBranch.el) === container2) { 16226 anchor = next(activeBranch); 16227 } 16228 unmount(activeBranch, parentComponent2, suspense, true); 16229 } 16230 if (!delayEnter) { 16231 move(pendingBranch, container2, anchor, 0); 16232 } 16233 } 16234 setActiveBranch(suspense, pendingBranch); 16235 suspense.pendingBranch = null; 16236 suspense.isInFallback = false; 16237 let parent = suspense.parent; 16238 let hasUnresolvedAncestor = false; 16239 while (parent) { 16240 if (parent.pendingBranch) { 16241 parent.effects.push(...effects); 16242 hasUnresolvedAncestor = true; 16243 break; 16244 } 16245 parent = parent.parent; 16246 } 16247 if (!hasUnresolvedAncestor && !delayEnter) { 16248 queuePostFlushCb(effects); 16249 } 16250 suspense.effects = []; 16251 if (isSuspensible) { 16252 if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) { 16253 parentSuspense.deps--; 16254 if (parentSuspense.deps === 0 && !sync) { 16255 parentSuspense.resolve(); 16256 } 16257 } 16258 } 16259 triggerEvent(vnode2, "onResolve"); 16260 }, 16261 fallback(fallbackVNode) { 16262 if (!suspense.pendingBranch) { 16263 return; 16264 } 16265 const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, namespace: namespace2 } = suspense; 16266 triggerEvent(vnode2, "onFallback"); 16267 const anchor2 = next(activeBranch); 16268 const mountFallback = () => { 16269 if (!suspense.isInFallback) { 16270 return; 16271 } 16272 patch( 16273 null, 16274 fallbackVNode, 16275 container2, 16276 anchor2, 16277 parentComponent2, 16278 null, 16279 // fallback tree will not have suspense context 16280 namespace2, 16281 slotScopeIds, 16282 optimized 16283 ); 16284 setActiveBranch(suspense, fallbackVNode); 16285 }; 16286 const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in"; 16287 if (delayEnter) { 16288 activeBranch.transition.afterLeave = mountFallback; 16289 } 16290 suspense.isInFallback = true; 16291 unmount( 16292 activeBranch, 16293 parentComponent2, 16294 null, 16295 // no suspense so unmount hooks fire now 16296 true 16297 // shouldRemove 16298 ); 16299 if (!delayEnter) { 16300 mountFallback(); 16301 } 16302 }, 16303 move(container2, anchor2, type) { 16304 suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type); 16305 suspense.container = container2; 16306 }, 16307 next() { 16308 return suspense.activeBranch && next(suspense.activeBranch); 16309 }, 16310 registerDep(instance, setupRenderEffect, optimized2) { 16311 const isInPendingSuspense = !!suspense.pendingBranch; 16312 if (isInPendingSuspense) { 16313 suspense.deps++; 16314 } 16315 const hydratedEl = instance.vnode.el; 16316 instance.asyncDep.catch((err) => { 16317 handleError(err, instance, 0); 16318 }).then((asyncSetupResult) => { 16319 if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) { 16320 return; 16321 } 16322 instance.asyncResolved = true; 16323 const { vnode: vnode2 } = instance; 16324 if (true) { 16325 pushWarningContext(vnode2); 16326 } 16327 handleSetupResult(instance, asyncSetupResult, false); 16328 if (hydratedEl) { 16329 vnode2.el = hydratedEl; 16330 } 16331 const placeholder = !hydratedEl && instance.subTree.el; 16332 setupRenderEffect( 16333 instance, 16334 vnode2, 16335 // component may have been moved before resolve. 16336 // if this is not a hydration, instance.subTree will be the comment 16337 // placeholder. 16338 parentNode(hydratedEl || instance.subTree.el), 16339 // anchor will not be used if this is hydration, so only need to 16340 // consider the comment placeholder case. 16341 hydratedEl ? null : next(instance.subTree), 16342 suspense, 16343 namespace, 16344 optimized2 16345 ); 16346 if (placeholder) { 16347 remove(placeholder); 16348 } 16349 updateHOCHostEl(instance, vnode2.el); 16350 if (true) { 16351 popWarningContext(); 16352 } 16353 if (isInPendingSuspense && --suspense.deps === 0) { 16354 suspense.resolve(); 16355 } 16356 }); 16357 }, 16358 unmount(parentSuspense2, doRemove) { 16359 suspense.isUnmounted = true; 16360 if (suspense.activeBranch) { 16361 unmount( 16362 suspense.activeBranch, 16363 parentComponent, 16364 parentSuspense2, 16365 doRemove 16366 ); 16367 } 16368 if (suspense.pendingBranch) { 16369 unmount( 16370 suspense.pendingBranch, 16371 parentComponent, 16372 parentSuspense2, 16373 doRemove 16374 ); 16375 } 16376 } 16377 }; 16378 return suspense; 16379} 16380function hydrateSuspense(node, vnode, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals, hydrateNode) { 16381 const suspense = vnode.suspense = createSuspenseBoundary( 16382 vnode, 16383 parentSuspense, 16384 parentComponent, 16385 node.parentNode, 16386 // eslint-disable-next-line no-restricted-globals 16387 document.createElement("div"), 16388 null, 16389 namespace, 16390 slotScopeIds, 16391 optimized, 16392 rendererInternals, 16393 true 16394 ); 16395 const result = hydrateNode( 16396 node, 16397 suspense.pendingBranch = vnode.ssContent, 16398 parentComponent, 16399 suspense, 16400 slotScopeIds, 16401 optimized 16402 ); 16403 if (suspense.deps === 0) { 16404 suspense.resolve(false, true); 16405 } 16406 return result; 16407} 16408function normalizeSuspenseChildren(vnode) { 16409 const { shapeFlag, children } = vnode; 16410 const isSlotChildren = shapeFlag & 32; 16411 vnode.ssContent = normalizeSuspenseSlot( 16412 isSlotChildren ? children.default : children 16413 ); 16414 vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment); 16415} 16416function normalizeSuspenseSlot(s) { 16417 let block; 16418 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(s)) { 16419 const trackBlock = isBlockTreeEnabled && s._c; 16420 if (trackBlock) { 16421 s._d = false; 16422 openBlock(); 16423 } 16424 s = s(); 16425 if (trackBlock) { 16426 s._d = true; 16427 block = currentBlock; 16428 closeBlock(); 16429 } 16430 } 16431 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(s)) { 16432 const singleChild = filterSingleRoot(s); 16433 if ( true && !singleChild && s.filter((child) => child !== NULL_DYNAMIC_COMPONENT).length > 0) { 16434 warn$1(`<Suspense> slots expect a single root node.`); 16435 } 16436 s = singleChild; 16437 } 16438 s = normalizeVNode(s); 16439 if (block && !s.dynamicChildren) { 16440 s.dynamicChildren = block.filter((c) => c !== s); 16441 } 16442 return s; 16443} 16444function queueEffectWithSuspense(fn, suspense) { 16445 if (suspense && suspense.pendingBranch) { 16446 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(fn)) { 16447 suspense.effects.push(...fn); 16448 } else { 16449 suspense.effects.push(fn); 16450 } 16451 } else { 16452 queuePostFlushCb(fn); 16453 } 16454} 16455function setActiveBranch(suspense, branch) { 16456 suspense.activeBranch = branch; 16457 const { vnode, parentComponent } = suspense; 16458 let el = branch.el; 16459 while (!el && branch.component) { 16460 branch = branch.component.subTree; 16461 el = branch.el; 16462 } 16463 vnode.el = el; 16464 if (parentComponent && parentComponent.subTree === vnode) { 16465 parentComponent.vnode.el = el; 16466 updateHOCHostEl(parentComponent, el); 16467 } 16468} 16469function isVNodeSuspensible(vnode) { 16470 const suspensible = vnode.props && vnode.props.suspensible; 16471 return suspensible != null && suspensible !== false; 16472} 16473 16474const Fragment = Symbol.for("v-fgt"); 16475const Text = Symbol.for("v-txt"); 16476const Comment = Symbol.for("v-cmt"); 16477const Static = Symbol.for("v-stc"); 16478const blockStack = []; 16479let currentBlock = null; 16480function openBlock(disableTracking = false) { 16481 blockStack.push(currentBlock = disableTracking ? null : []); 16482} 16483function closeBlock() { 16484 blockStack.pop(); 16485 currentBlock = blockStack[blockStack.length - 1] || null; 16486} 16487let isBlockTreeEnabled = 1; 16488function setBlockTracking(value, inVOnce = false) { 16489 isBlockTreeEnabled += value; 16490 if (value < 0 && currentBlock && inVOnce) { 16491 currentBlock.hasOnce = true; 16492 } 16493} 16494function setupBlock(vnode) { 16495 vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR : null; 16496 closeBlock(); 16497 if (isBlockTreeEnabled > 0 && currentBlock) { 16498 currentBlock.push(vnode); 16499 } 16500 return vnode; 16501} 16502function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) { 16503 return setupBlock( 16504 createBaseVNode( 16505 type, 16506 props, 16507 children, 16508 patchFlag, 16509 dynamicProps, 16510 shapeFlag, 16511 true 16512 ) 16513 ); 16514} 16515function createBlock(type, props, children, patchFlag, dynamicProps) { 16516 return setupBlock( 16517 createVNode( 16518 type, 16519 props, 16520 children, 16521 patchFlag, 16522 dynamicProps, 16523 true 16524 ) 16525 ); 16526} 16527function isVNode(value) { 16528 return value ? value.__v_isVNode === true : false; 16529} 16530function isSameVNodeType(n1, n2) { 16531 if ( true && n2.shapeFlag & 6 && n1.component) { 16532 const dirtyInstances = hmrDirtyComponents.get(n2.type); 16533 if (dirtyInstances && dirtyInstances.has(n1.component)) { 16534 n1.shapeFlag &= ~256; 16535 n2.shapeFlag &= ~512; 16536 return false; 16537 } 16538 } 16539 return n1.type === n2.type && n1.key === n2.key; 16540} 16541let vnodeArgsTransformer; 16542function transformVNodeArgs(transformer) { 16543 vnodeArgsTransformer = transformer; 16544} 16545const createVNodeWithArgsTransform = (...args) => { 16546 return _createVNode( 16547 ...vnodeArgsTransformer ? vnodeArgsTransformer(args, currentRenderingInstance) : args 16548 ); 16549}; 16550const normalizeKey = ({ key }) => key != null ? key : null; 16551const normalizeRef = ({ 16552 ref, 16553 ref_key, 16554 ref_for 16555}) => { 16556 if (typeof ref === "number") { 16557 ref = "" + ref; 16558 } 16559 return ref != null ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(ref) || (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(ref) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null; 16560}; 16561function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) { 16562 const vnode = { 16563 __v_isVNode: true, 16564 __v_skip: true, 16565 type, 16566 props, 16567 key: props && normalizeKey(props), 16568 ref: props && normalizeRef(props), 16569 scopeId: currentScopeId, 16570 slotScopeIds: null, 16571 children, 16572 component: null, 16573 suspense: null, 16574 ssContent: null, 16575 ssFallback: null, 16576 dirs: null, 16577 transition: null, 16578 el: null, 16579 anchor: null, 16580 target: null, 16581 targetStart: null, 16582 targetAnchor: null, 16583 staticCount: 0, 16584 shapeFlag, 16585 patchFlag, 16586 dynamicProps, 16587 dynamicChildren: null, 16588 appContext: null, 16589 ctx: currentRenderingInstance 16590 }; 16591 if (needFullChildrenNormalization) { 16592 normalizeChildren(vnode, children); 16593 if (shapeFlag & 128) { 16594 type.normalize(vnode); 16595 } 16596 } else if (children) { 16597 vnode.shapeFlag |= (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(children) ? 8 : 16; 16598 } 16599 if ( true && vnode.key !== vnode.key) { 16600 warn$1(`VNode created with invalid key (NaN). VNode type:`, vnode.type); 16601 } 16602 if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself 16603 !isBlockNode && // has current parent block 16604 currentBlock && // presence of a patch flag indicates this node needs patching on updates. 16605 // component nodes also should always be patched, because even if the 16606 // component doesn't need to update, it needs to persist the instance on to 16607 // the next vnode so that it can be properly unmounted later. 16608 (vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the 16609 // vnode should not be considered dynamic due to handler caching. 16610 vnode.patchFlag !== 32) { 16611 currentBlock.push(vnode); 16612 } 16613 return vnode; 16614} 16615const createVNode = true ? createVNodeWithArgsTransform : 0; 16616function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) { 16617 if (!type || type === NULL_DYNAMIC_COMPONENT) { 16618 if ( true && !type) { 16619 warn$1(`Invalid vnode type when creating vnode: ${type}.`); 16620 } 16621 type = Comment; 16622 } 16623 if (isVNode(type)) { 16624 const cloned = cloneVNode( 16625 type, 16626 props, 16627 true 16628 /* mergeRef: true */ 16629 ); 16630 if (children) { 16631 normalizeChildren(cloned, children); 16632 } 16633 if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) { 16634 if (cloned.shapeFlag & 6) { 16635 currentBlock[currentBlock.indexOf(type)] = cloned; 16636 } else { 16637 currentBlock.push(cloned); 16638 } 16639 } 16640 cloned.patchFlag = -2; 16641 return cloned; 16642 } 16643 if (isClassComponent(type)) { 16644 type = type.__vccOpts; 16645 } 16646 if (props) { 16647 props = guardReactiveProps(props); 16648 let { class: klass, style } = props; 16649 if (klass && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(klass)) { 16650 props.class = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass)(klass); 16651 } 16652 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(style)) { 16653 if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy)(style) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(style)) { 16654 style = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, style); 16655 } 16656 props.style = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle)(style); 16657 } 16658 } 16659 const shapeFlag = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(type) ? 4 : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(type) ? 2 : 0; 16660 if ( true && shapeFlag & 4 && (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy)(type)) { 16661 type = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(type); 16662 warn$1( 16663 `Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`, 16664 ` 16665Component that was made reactive: `, 16666 type 16667 ); 16668 } 16669 return createBaseVNode( 16670 type, 16671 props, 16672 children, 16673 patchFlag, 16674 dynamicProps, 16675 shapeFlag, 16676 isBlockNode, 16677 true 16678 ); 16679} 16680function guardReactiveProps(props) { 16681 if (!props) return null; 16682 return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy)(props) || isInternalObject(props) ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, props) : props; 16683} 16684function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) { 16685 const { props, ref, patchFlag, children, transition } = vnode; 16686 const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props; 16687 const cloned = { 16688 __v_isVNode: true, 16689 __v_skip: true, 16690 type: vnode.type, 16691 props: mergedProps, 16692 key: mergedProps && normalizeKey(mergedProps), 16693 ref: extraProps && extraProps.ref ? ( 16694 // #2078 in the case of <component :is="vnode" ref="extra"/> 16695 // if the vnode itself already has a ref, cloneVNode will need to merge 16696 // the refs so the single vnode can be set on multiple refs 16697 mergeRef && ref ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) 16698 ) : ref, 16699 scopeId: vnode.scopeId, 16700 slotScopeIds: vnode.slotScopeIds, 16701 children: true && patchFlag === -1 && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(children) ? children.map(deepCloneVNode) : children, 16702 target: vnode.target, 16703 targetStart: vnode.targetStart, 16704 targetAnchor: vnode.targetAnchor, 16705 staticCount: vnode.staticCount, 16706 shapeFlag: vnode.shapeFlag, 16707 // if the vnode is cloned with extra props, we can no longer assume its 16708 // existing patch flag to be reliable and need to add the FULL_PROPS flag. 16709 // note: preserve flag for fragments since they use the flag for children 16710 // fast paths only. 16711 patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag, 16712 dynamicProps: vnode.dynamicProps, 16713 dynamicChildren: vnode.dynamicChildren, 16714 appContext: vnode.appContext, 16715 dirs: vnode.dirs, 16716 transition, 16717 // These should technically only be non-null on mounted VNodes. However, 16718 // they *should* be copied for kept-alive vnodes. So we just always copy 16719 // them since them being non-null during a mount doesn't affect the logic as 16720 // they will simply be overwritten. 16721 component: vnode.component, 16722 suspense: vnode.suspense, 16723 ssContent: vnode.ssContent && cloneVNode(vnode.ssContent), 16724 ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback), 16725 el: vnode.el, 16726 anchor: vnode.anchor, 16727 ctx: vnode.ctx, 16728 ce: vnode.ce 16729 }; 16730 if (transition && cloneTransition) { 16731 setTransitionHooks( 16732 cloned, 16733 transition.clone(cloned) 16734 ); 16735 } 16736 return cloned; 16737} 16738function deepCloneVNode(vnode) { 16739 const cloned = cloneVNode(vnode); 16740 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(vnode.children)) { 16741 cloned.children = vnode.children.map(deepCloneVNode); 16742 } 16743 return cloned; 16744} 16745function createTextVNode(text = " ", flag = 0) { 16746 return createVNode(Text, null, text, flag); 16747} 16748function createStaticVNode(content, numberOfNodes) { 16749 const vnode = createVNode(Static, null, content); 16750 vnode.staticCount = numberOfNodes; 16751 return vnode; 16752} 16753function createCommentVNode(text = "", asBlock = false) { 16754 return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text); 16755} 16756function normalizeVNode(child) { 16757 if (child == null || typeof child === "boolean") { 16758 return createVNode(Comment); 16759 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(child)) { 16760 return createVNode( 16761 Fragment, 16762 null, 16763 // #3666, avoid reference pollution when reusing vnode 16764 child.slice() 16765 ); 16766 } else if (isVNode(child)) { 16767 return cloneIfMounted(child); 16768 } else { 16769 return createVNode(Text, null, String(child)); 16770 } 16771} 16772function cloneIfMounted(child) { 16773 return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child); 16774} 16775function normalizeChildren(vnode, children) { 16776 let type = 0; 16777 const { shapeFlag } = vnode; 16778 if (children == null) { 16779 children = null; 16780 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(children)) { 16781 type = 16; 16782 } else if (typeof children === "object") { 16783 if (shapeFlag & (1 | 64)) { 16784 const slot = children.default; 16785 if (slot) { 16786 slot._c && (slot._d = false); 16787 normalizeChildren(vnode, slot()); 16788 slot._c && (slot._d = true); 16789 } 16790 return; 16791 } else { 16792 type = 32; 16793 const slotFlag = children._; 16794 if (!slotFlag && !isInternalObject(children)) { 16795 children._ctx = currentRenderingInstance; 16796 } else if (slotFlag === 3 && currentRenderingInstance) { 16797 if (currentRenderingInstance.slots._ === 1) { 16798 children._ = 1; 16799 } else { 16800 children._ = 2; 16801 vnode.patchFlag |= 1024; 16802 } 16803 } 16804 } 16805 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(children)) { 16806 children = { default: children, _ctx: currentRenderingInstance }; 16807 type = 32; 16808 } else { 16809 children = String(children); 16810 if (shapeFlag & 64) { 16811 type = 16; 16812 children = [createTextVNode(children)]; 16813 } else { 16814 type = 8; 16815 } 16816 } 16817 vnode.children = children; 16818 vnode.shapeFlag |= type; 16819} 16820function mergeProps(...args) { 16821 const ret = {}; 16822 for (let i = 0; i < args.length; i++) { 16823 const toMerge = args[i]; 16824 for (const key in toMerge) { 16825 if (key === "class") { 16826 if (ret.class !== toMerge.class) { 16827 ret.class = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass)([ret.class, toMerge.class]); 16828 } 16829 } else if (key === "style") { 16830 ret.style = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle)([ret.style, toMerge.style]); 16831 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) { 16832 const existing = ret[key]; 16833 const incoming = toMerge[key]; 16834 if (incoming && existing !== incoming && !((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(existing) && existing.includes(incoming))) { 16835 ret[key] = existing ? [].concat(existing, incoming) : incoming; 16836 } 16837 } else if (key !== "") { 16838 ret[key] = toMerge[key]; 16839 } 16840 } 16841 } 16842 return ret; 16843} 16844function invokeVNodeHook(hook, instance, vnode, prevVNode = null) { 16845 callWithAsyncErrorHandling(hook, instance, 7, [ 16846 vnode, 16847 prevVNode 16848 ]); 16849} 16850 16851const emptyAppContext = createAppContext(); 16852let uid = 0; 16853function createComponentInstance(vnode, parent, suspense) { 16854 const type = vnode.type; 16855 const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext; 16856 const instance = { 16857 uid: uid++, 16858 vnode, 16859 type, 16860 parent, 16861 appContext, 16862 root: null, 16863 // to be immediately set 16864 next: null, 16865 subTree: null, 16866 // will be set synchronously right after creation 16867 effect: null, 16868 update: null, 16869 // will be set synchronously right after creation 16870 job: null, 16871 scope: new _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.EffectScope( 16872 true 16873 /* detached */ 16874 ), 16875 render: null, 16876 proxy: null, 16877 exposed: null, 16878 exposeProxy: null, 16879 withProxy: null, 16880 provides: parent ? parent.provides : Object.create(appContext.provides), 16881 ids: parent ? parent.ids : ["", 0, 0], 16882 accessCache: null, 16883 renderCache: [], 16884 // local resolved assets 16885 components: null, 16886 directives: null, 16887 // resolved props and emits options 16888 propsOptions: normalizePropsOptions(type, appContext), 16889 emitsOptions: normalizeEmitsOptions(type, appContext), 16890 // emit 16891 emit: null, 16892 // to be set immediately 16893 emitted: null, 16894 // props default value 16895 propsDefaults: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 16896 // inheritAttrs 16897 inheritAttrs: type.inheritAttrs, 16898 // state 16899 ctx: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 16900 data: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 16901 props: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 16902 attrs: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 16903 slots: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 16904 refs: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 16905 setupState: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 16906 setupContext: null, 16907 // suspense related 16908 suspense, 16909 suspenseId: suspense ? suspense.pendingId : 0, 16910 asyncDep: null, 16911 asyncResolved: false, 16912 // lifecycle hooks 16913 // not using enums here because it results in computed properties 16914 isMounted: false, 16915 isUnmounted: false, 16916 isDeactivated: false, 16917 bc: null, 16918 c: null, 16919 bm: null, 16920 m: null, 16921 bu: null, 16922 u: null, 16923 um: null, 16924 bum: null, 16925 da: null, 16926 a: null, 16927 rtg: null, 16928 rtc: null, 16929 ec: null, 16930 sp: null 16931 }; 16932 if (true) { 16933 instance.ctx = createDevRenderContext(instance); 16934 } else {} 16935 instance.root = parent ? parent.root : instance; 16936 instance.emit = emit.bind(null, instance); 16937 if (vnode.ce) { 16938 vnode.ce(instance); 16939 } 16940 return instance; 16941} 16942let currentInstance = null; 16943const getCurrentInstance = () => currentInstance || currentRenderingInstance; 16944let internalSetCurrentInstance; 16945let setInSSRSetupState; 16946{ 16947 const g = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)(); 16948 const registerGlobalSetter = (key, setter) => { 16949 let setters; 16950 if (!(setters = g[key])) setters = g[key] = []; 16951 setters.push(setter); 16952 return (v) => { 16953 if (setters.length > 1) setters.forEach((set) => set(v)); 16954 else setters[0](v); 16955 }; 16956 }; 16957 internalSetCurrentInstance = registerGlobalSetter( 16958 `__VUE_INSTANCE_SETTERS__`, 16959 (v) => currentInstance = v 16960 ); 16961 setInSSRSetupState = registerGlobalSetter( 16962 `__VUE_SSR_SETTERS__`, 16963 (v) => isInSSRComponentSetup = v 16964 ); 16965} 16966const setCurrentInstance = (instance) => { 16967 const prev = currentInstance; 16968 internalSetCurrentInstance(instance); 16969 instance.scope.on(); 16970 return () => { 16971 instance.scope.off(); 16972 internalSetCurrentInstance(prev); 16973 }; 16974}; 16975const unsetCurrentInstance = () => { 16976 currentInstance && currentInstance.scope.off(); 16977 internalSetCurrentInstance(null); 16978}; 16979const isBuiltInTag = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)("slot,component"); 16980function validateComponentName(name, { isNativeTag }) { 16981 if (isBuiltInTag(name) || isNativeTag(name)) { 16982 warn$1( 16983 "Do not use built-in or reserved HTML elements as component id: " + name 16984 ); 16985 } 16986} 16987function isStatefulComponent(instance) { 16988 return instance.vnode.shapeFlag & 4; 16989} 16990let isInSSRComponentSetup = false; 16991function setupComponent(instance, isSSR = false, optimized = false) { 16992 isSSR && setInSSRSetupState(isSSR); 16993 const { props, children } = instance.vnode; 16994 const isStateful = isStatefulComponent(instance); 16995 initProps(instance, props, isStateful, isSSR); 16996 initSlots(instance, children, optimized); 16997 const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0; 16998 isSSR && setInSSRSetupState(false); 16999 return setupResult; 17000} 17001function setupStatefulComponent(instance, isSSR) { 17002 var _a; 17003 const Component = instance.type; 17004 if (true) { 17005 if (Component.name) { 17006 validateComponentName(Component.name, instance.appContext.config); 17007 } 17008 if (Component.components) { 17009 const names = Object.keys(Component.components); 17010 for (let i = 0; i < names.length; i++) { 17011 validateComponentName(names[i], instance.appContext.config); 17012 } 17013 } 17014 if (Component.directives) { 17015 const names = Object.keys(Component.directives); 17016 for (let i = 0; i < names.length; i++) { 17017 validateDirectiveName(names[i]); 17018 } 17019 } 17020 if (Component.compilerOptions && isRuntimeOnly()) { 17021 warn$1( 17022 `"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.` 17023 ); 17024 } 17025 } 17026 instance.accessCache = /* @__PURE__ */ Object.create(null); 17027 instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers); 17028 if (true) { 17029 exposePropsOnRenderContext(instance); 17030 } 17031 const { setup } = Component; 17032 if (setup) { 17033 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 17034 const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null; 17035 const reset = setCurrentInstance(instance); 17036 const setupResult = callWithErrorHandling( 17037 setup, 17038 instance, 17039 0, 17040 [ 17041 true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(instance.props) : 0, 17042 setupContext 17043 ] 17044 ); 17045 const isAsyncSetup = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(setupResult); 17046 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 17047 reset(); 17048 if ((isAsyncSetup || instance.sp) && !isAsyncWrapper(instance)) { 17049 markAsyncBoundary(instance); 17050 } 17051 if (isAsyncSetup) { 17052 setupResult.then(unsetCurrentInstance, unsetCurrentInstance); 17053 if (isSSR) { 17054 return setupResult.then((resolvedResult) => { 17055 handleSetupResult(instance, resolvedResult, isSSR); 17056 }).catch((e) => { 17057 handleError(e, instance, 0); 17058 }); 17059 } else { 17060 instance.asyncDep = setupResult; 17061 if ( true && !instance.suspense) { 17062 const name = (_a = Component.name) != null ? _a : "Anonymous"; 17063 warn$1( 17064 `Component <${name}>: setup function returned a promise, but no <Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.` 17065 ); 17066 } 17067 } 17068 } else { 17069 handleSetupResult(instance, setupResult, isSSR); 17070 } 17071 } else { 17072 finishComponentSetup(instance, isSSR); 17073 } 17074} 17075function handleSetupResult(instance, setupResult, isSSR) { 17076 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(setupResult)) { 17077 if (instance.type.__ssrInlineRender) { 17078 instance.ssrRender = setupResult; 17079 } else { 17080 instance.render = setupResult; 17081 } 17082 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(setupResult)) { 17083 if ( true && isVNode(setupResult)) { 17084 warn$1( 17085 `setup() should not return VNodes directly - return a render function instead.` 17086 ); 17087 } 17088 if (true) { 17089 instance.devtoolsRawSetupState = setupResult; 17090 } 17091 instance.setupState = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.proxyRefs)(setupResult); 17092 if (true) { 17093 exposeSetupStateOnRenderContext(instance); 17094 } 17095 } else if ( true && setupResult !== void 0) { 17096 warn$1( 17097 `setup() should return an object. Received: ${setupResult === null ? "null" : typeof setupResult}` 17098 ); 17099 } 17100 finishComponentSetup(instance, isSSR); 17101} 17102let compile; 17103let installWithProxy; 17104function registerRuntimeCompiler(_compile) { 17105 compile = _compile; 17106 installWithProxy = (i) => { 17107 if (i.render._rc) { 17108 i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers); 17109 } 17110 }; 17111} 17112const isRuntimeOnly = () => !compile; 17113function finishComponentSetup(instance, isSSR, skipOptions) { 17114 const Component = instance.type; 17115 if (!instance.render) { 17116 if (!isSSR && compile && !Component.render) { 17117 const template = Component.template || true && resolveMergedOptions(instance).template; 17118 if (template) { 17119 if (true) { 17120 startMeasure(instance, `compile`); 17121 } 17122 const { isCustomElement, compilerOptions } = instance.appContext.config; 17123 const { delimiters, compilerOptions: componentCompilerOptions } = Component; 17124 const finalCompilerOptions = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)( 17125 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)( 17126 { 17127 isCustomElement, 17128 delimiters 17129 }, 17130 compilerOptions 17131 ), 17132 componentCompilerOptions 17133 ); 17134 Component.render = compile(template, finalCompilerOptions); 17135 if (true) { 17136 endMeasure(instance, `compile`); 17137 } 17138 } 17139 } 17140 instance.render = Component.render || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP; 17141 if (installWithProxy) { 17142 installWithProxy(instance); 17143 } 17144 } 17145 if (true) { 17146 const reset = setCurrentInstance(instance); 17147 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 17148 try { 17149 applyOptions(instance); 17150 } finally { 17151 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 17152 reset(); 17153 } 17154 } 17155 if ( true && !Component.render && instance.render === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP && !isSSR) { 17156 if (!compile && Component.template) { 17157 warn$1( 17158 `Component provided template option but runtime compilation is not supported in this build of Vue.` + (` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".` ) 17159 ); 17160 } else { 17161 warn$1(`Component is missing template or render function: `, Component); 17162 } 17163 } 17164} 17165const attrsProxyHandlers = true ? { 17166 get(target, key) { 17167 markAttrsAccessed(); 17168 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.track)(target, "get", ""); 17169 return target[key]; 17170 }, 17171 set() { 17172 warn$1(`setupContext.attrs is readonly.`); 17173 return false; 17174 }, 17175 deleteProperty() { 17176 warn$1(`setupContext.attrs is readonly.`); 17177 return false; 17178 } 17179} : 0; 17180function getSlotsProxy(instance) { 17181 return new Proxy(instance.slots, { 17182 get(target, key) { 17183 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.track)(instance, "get", "$slots"); 17184 return target[key]; 17185 } 17186 }); 17187} 17188function createSetupContext(instance) { 17189 const expose = (exposed) => { 17190 if (true) { 17191 if (instance.exposed) { 17192 warn$1(`expose() should be called only once per setup().`); 17193 } 17194 if (exposed != null) { 17195 let exposedType = typeof exposed; 17196 if (exposedType === "object") { 17197 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(exposed)) { 17198 exposedType = "array"; 17199 } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(exposed)) { 17200 exposedType = "ref"; 17201 } 17202 } 17203 if (exposedType !== "object") { 17204 warn$1( 17205 `expose() should be passed a plain object, received ${exposedType}.` 17206 ); 17207 } 17208 } 17209 } 17210 instance.exposed = exposed || {}; 17211 }; 17212 if (true) { 17213 let attrsProxy; 17214 let slotsProxy; 17215 return Object.freeze({ 17216 get attrs() { 17217 return attrsProxy || (attrsProxy = new Proxy(instance.attrs, attrsProxyHandlers)); 17218 }, 17219 get slots() { 17220 return slotsProxy || (slotsProxy = getSlotsProxy(instance)); 17221 }, 17222 get emit() { 17223 return (event, ...args) => instance.emit(event, ...args); 17224 }, 17225 expose 17226 }); 17227 } else {} 17228} 17229function getComponentPublicInstance(instance) { 17230 if (instance.exposed) { 17231 return instance.exposeProxy || (instance.exposeProxy = new Proxy((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.proxyRefs)((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.markRaw)(instance.exposed)), { 17232 get(target, key) { 17233 if (key in target) { 17234 return target[key]; 17235 } else if (key in publicPropertiesMap) { 17236 return publicPropertiesMap[key](instance); 17237 } 17238 }, 17239 has(target, key) { 17240 return key in target || key in publicPropertiesMap; 17241 } 17242 })); 17243 } else { 17244 return instance.proxy; 17245 } 17246} 17247const classifyRE = /(?:^|[-_])(\w)/g; 17248const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, ""); 17249function getComponentName(Component, includeInferred = true) { 17250 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name; 17251} 17252function formatComponentName(instance, Component, isRoot = false) { 17253 let name = getComponentName(Component); 17254 if (!name && Component.__file) { 17255 const match = Component.__file.match(/([^/\\]+)\.\w+$/); 17256 if (match) { 17257 name = match[1]; 17258 } 17259 } 17260 if (!name && instance && instance.parent) { 17261 const inferFromRegistry = (registry) => { 17262 for (const key in registry) { 17263 if (registry[key] === Component) { 17264 return key; 17265 } 17266 } 17267 }; 17268 name = inferFromRegistry( 17269 instance.components || instance.parent.type.components 17270 ) || inferFromRegistry(instance.appContext.components); 17271 } 17272 return name ? classify(name) : isRoot ? `App` : `Anonymous`; 17273} 17274function isClassComponent(value) { 17275 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value) && "__vccOpts" in value; 17276} 17277 17278const computed = (getterOrOptions, debugOptions) => { 17279 const c = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.computed)(getterOrOptions, debugOptions, isInSSRComponentSetup); 17280 if (true) { 17281 const i = getCurrentInstance(); 17282 if (i && i.appContext.config.warnRecursiveComputed) { 17283 c._warnRecursive = true; 17284 } 17285 } 17286 return c; 17287}; 17288 17289function h(type, propsOrChildren, children) { 17290 const l = arguments.length; 17291 if (l === 2) { 17292 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(propsOrChildren) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(propsOrChildren)) { 17293 if (isVNode(propsOrChildren)) { 17294 return createVNode(type, null, [propsOrChildren]); 17295 } 17296 return createVNode(type, propsOrChildren); 17297 } else { 17298 return createVNode(type, null, propsOrChildren); 17299 } 17300 } else { 17301 if (l > 3) { 17302 children = Array.prototype.slice.call(arguments, 2); 17303 } else if (l === 3 && isVNode(children)) { 17304 children = [children]; 17305 } 17306 return createVNode(type, propsOrChildren, children); 17307 } 17308} 17309 17310function initCustomFormatter() { 17311 if ( false || typeof window === "undefined") { 17312 return; 17313 } 17314 const vueStyle = { style: "color:#3ba776" }; 17315 const numberStyle = { style: "color:#1677ff" }; 17316 const stringStyle = { style: "color:#f5222d" }; 17317 const keywordStyle = { style: "color:#eb2f96" }; 17318 const formatter = { 17319 __vue_custom_formatter: true, 17320 header(obj) { 17321 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(obj)) { 17322 return null; 17323 } 17324 if (obj.__isVue) { 17325 return ["div", vueStyle, `VueInstance`]; 17326 } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(obj)) { 17327 return [ 17328 "div", 17329 {}, 17330 ["span", vueStyle, genRefFlag(obj)], 17331 "<", 17332 // avoid debugger accessing value affecting behavior 17333 formatValue("_value" in obj ? obj._value : obj), 17334 `>` 17335 ]; 17336 } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive)(obj)) { 17337 return [ 17338 "div", 17339 {}, 17340 ["span", vueStyle, (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(obj) ? "ShallowReactive" : "Reactive"], 17341 "<", 17342 formatValue(obj), 17343 `>${(0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReadonly)(obj) ? ` (readonly)` : ``}` 17344 ]; 17345 } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReadonly)(obj)) { 17346 return [ 17347 "div", 17348 {}, 17349 ["span", vueStyle, (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(obj) ? "ShallowReadonly" : "Readonly"], 17350 "<", 17351 formatValue(obj), 17352 ">" 17353 ]; 17354 } 17355 return null; 17356 }, 17357 hasBody(obj) { 17358 return obj && obj.__isVue; 17359 }, 17360 body(obj) { 17361 if (obj && obj.__isVue) { 17362 return [ 17363 "div", 17364 {}, 17365 ...formatInstance(obj.$) 17366 ]; 17367 } 17368 } 17369 }; 17370 function formatInstance(instance) { 17371 const blocks = []; 17372 if (instance.type.props && instance.props) { 17373 blocks.push(createInstanceBlock("props", (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(instance.props))); 17374 } 17375 if (instance.setupState !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) { 17376 blocks.push(createInstanceBlock("setup", instance.setupState)); 17377 } 17378 if (instance.data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) { 17379 blocks.push(createInstanceBlock("data", (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(instance.data))); 17380 } 17381 const computed = extractKeys(instance, "computed"); 17382 if (computed) { 17383 blocks.push(createInstanceBlock("computed", computed)); 17384 } 17385 const injected = extractKeys(instance, "inject"); 17386 if (injected) { 17387 blocks.push(createInstanceBlock("injected", injected)); 17388 } 17389 blocks.push([ 17390 "div", 17391 {}, 17392 [ 17393 "span", 17394 { 17395 style: keywordStyle.style + ";opacity:0.66" 17396 }, 17397 "$ (internal): " 17398 ], 17399 ["object", { object: instance }] 17400 ]); 17401 return blocks; 17402 } 17403 function createInstanceBlock(type, target) { 17404 target = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, target); 17405 if (!Object.keys(target).length) { 17406 return ["span", {}]; 17407 } 17408 return [ 17409 "div", 17410 { style: "line-height:1.25em;margin-bottom:0.6em" }, 17411 [ 17412 "div", 17413 { 17414 style: "color:#476582" 17415 }, 17416 type 17417 ], 17418 [ 17419 "div", 17420 { 17421 style: "padding-left:1.25em" 17422 }, 17423 ...Object.keys(target).map((key) => { 17424 return [ 17425 "div", 17426 {}, 17427 ["span", keywordStyle, key + ": "], 17428 formatValue(target[key], false) 17429 ]; 17430 }) 17431 ] 17432 ]; 17433 } 17434 function formatValue(v, asRaw = true) { 17435 if (typeof v === "number") { 17436 return ["span", numberStyle, v]; 17437 } else if (typeof v === "string") { 17438 return ["span", stringStyle, JSON.stringify(v)]; 17439 } else if (typeof v === "boolean") { 17440 return ["span", keywordStyle, v]; 17441 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(v)) { 17442 return ["object", { object: asRaw ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(v) : v }]; 17443 } else { 17444 return ["span", stringStyle, String(v)]; 17445 } 17446 } 17447 function extractKeys(instance, type) { 17448 const Comp = instance.type; 17449 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(Comp)) { 17450 return; 17451 } 17452 const extracted = {}; 17453 for (const key in instance.ctx) { 17454 if (isKeyOfType(Comp, key, type)) { 17455 extracted[key] = instance.ctx[key]; 17456 } 17457 } 17458 return extracted; 17459 } 17460 function isKeyOfType(Comp, key, type) { 17461 const opts = Comp[type]; 17462 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(opts) && opts.includes(key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(opts) && key in opts) { 17463 return true; 17464 } 17465 if (Comp.extends && isKeyOfType(Comp.extends, key, type)) { 17466 return true; 17467 } 17468 if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) { 17469 return true; 17470 } 17471 } 17472 function genRefFlag(v) { 17473 if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(v)) { 17474 return `ShallowRef`; 17475 } 17476 if (v.effect) { 17477 return `ComputedRef`; 17478 } 17479 return `Ref`; 17480 } 17481 if (window.devtoolsFormatters) { 17482 window.devtoolsFormatters.push(formatter); 17483 } else { 17484 window.devtoolsFormatters = [formatter]; 17485 } 17486} 17487 17488function withMemo(memo, render, cache, index) { 17489 const cached = cache[index]; 17490 if (cached && isMemoSame(cached, memo)) { 17491 return cached; 17492 } 17493 const ret = render(); 17494 ret.memo = memo.slice(); 17495 ret.cacheIndex = index; 17496 return cache[index] = ret; 17497} 17498function isMemoSame(cached, memo) { 17499 const prev = cached.memo; 17500 if (prev.length != memo.length) { 17501 return false; 17502 } 17503 for (let i = 0; i < prev.length; i++) { 17504 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(prev[i], memo[i])) { 17505 return false; 17506 } 17507 } 17508 if (isBlockTreeEnabled > 0 && currentBlock) { 17509 currentBlock.push(cached); 17510 } 17511 return true; 17512} 17513 17514const version = "3.5.13"; 17515const warn = true ? warn$1 : 0; 17516const ErrorTypeStrings = ErrorTypeStrings$1 ; 17517const devtools = true ? devtools$1 : 0; 17518const setDevtoolsHook = true ? setDevtoolsHook$1 : 0; 17519const _ssrUtils = { 17520 createComponentInstance, 17521 setupComponent, 17522 renderComponentRoot, 17523 setCurrentRenderingInstance, 17524 isVNode: isVNode, 17525 normalizeVNode, 17526 getComponentPublicInstance, 17527 ensureValidVNode, 17528 pushWarningContext, 17529 popWarningContext 17530}; 17531const ssrUtils = _ssrUtils ; 17532const resolveFilter = null; 17533const compatUtils = null; 17534const DeprecationTypes = null; 17535 17536 17537 17538 17539/***/ }), 17540
vendor: 82,808 bytes, lines 17541-19585
17541/***/ "./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js": 17542/*!***********************************************************************!*\ 17543 !*** ./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js ***! 17544 \***********************************************************************/ 17545/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 17546 17547"use strict"; 17548__webpack_require__.r(__webpack_exports__); 17549/* harmony export */ __webpack_require__.d(__webpack_exports__, { 17550/* harmony export */ BaseTransition: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransition), 17551/* harmony export */ BaseTransitionPropsValidators: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransitionPropsValidators), 17552/* harmony export */ Comment: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Comment), 17553/* harmony export */ DeprecationTypes: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.DeprecationTypes), 17554/* harmony export */ EffectScope: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.EffectScope), 17555/* harmony export */ ErrorCodes: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ErrorCodes), 17556/* harmony export */ ErrorTypeStrings: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ErrorTypeStrings), 17557/* harmony export */ Fragment: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Fragment), 17558/* harmony export */ KeepAlive: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.KeepAlive), 17559/* harmony export */ ReactiveEffect: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect), 17560/* harmony export */ Static: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Static), 17561/* harmony export */ Suspense: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Suspense), 17562/* harmony export */ Teleport: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Teleport), 17563/* harmony export */ Text: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Text), 17564/* harmony export */ TrackOpTypes: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.TrackOpTypes), 17565/* harmony export */ Transition: () => (/* binding */ Transition), 17566/* harmony export */ TransitionGroup: () => (/* binding */ TransitionGroup), 17567/* harmony export */ TriggerOpTypes: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.TriggerOpTypes), 17568/* harmony export */ VueElement: () => (/* binding */ VueElement), 17569/* harmony export */ assertNumber: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.assertNumber), 17570/* harmony export */ callWithAsyncErrorHandling: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling), 17571/* harmony export */ callWithErrorHandling: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.callWithErrorHandling), 17572/* harmony export */ camelize: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.camelize), 17573/* harmony export */ capitalize: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.capitalize), 17574/* harmony export */ cloneVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.cloneVNode), 17575/* harmony export */ compatUtils: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.compatUtils), 17576/* harmony export */ computed: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.computed), 17577/* harmony export */ createApp: () => (/* binding */ createApp), 17578/* harmony export */ createBlock: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createBlock), 17579/* harmony export */ createCommentVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode), 17580/* harmony export */ createElementBlock: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createElementBlock), 17581/* harmony export */ createElementVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createElementVNode), 17582/* harmony export */ createHydrationRenderer: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer), 17583/* harmony export */ createPropsRestProxy: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createPropsRestProxy), 17584/* harmony export */ createRenderer: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createRenderer), 17585/* harmony export */ createSSRApp: () => (/* binding */ createSSRApp), 17586/* harmony export */ createSlots: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createSlots), 17587/* harmony export */ createStaticVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode), 17588/* harmony export */ createTextVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createTextVNode), 17589/* harmony export */ createVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createVNode), 17590/* harmony export */ customRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.customRef), 17591/* harmony export */ defineAsyncComponent: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineAsyncComponent), 17592/* harmony export */ defineComponent: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineComponent), 17593/* harmony export */ defineCustomElement: () => (/* binding */ defineCustomElement), 17594/* harmony export */ defineEmits: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineEmits), 17595/* harmony export */ defineExpose: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineExpose), 17596/* harmony export */ defineModel: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineModel), 17597/* harmony export */ defineOptions: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineOptions), 17598/* harmony export */ defineProps: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineProps), 17599/* harmony export */ defineSSRCustomElement: () => (/* binding */ defineSSRCustomElement), 17600/* harmony export */ defineSlots: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineSlots), 17601/* harmony export */ devtools: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.devtools), 17602/* harmony export */ effect: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.effect), 17603/* harmony export */ effectScope: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.effectScope), 17604/* harmony export */ getCurrentInstance: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance), 17605/* harmony export */ getCurrentScope: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope), 17606/* harmony export */ getCurrentWatcher: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentWatcher), 17607/* harmony export */ getTransitionRawChildren: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren), 17608/* harmony export */ guardReactiveProps: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.guardReactiveProps), 17609/* harmony export */ h: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.h), 17610/* harmony export */ handleError: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.handleError), 17611/* harmony export */ hasInjectionContext: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.hasInjectionContext), 17612/* harmony export */ hydrate: () => (/* binding */ hydrate), 17613/* harmony export */ hydrateOnIdle: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.hydrateOnIdle), 17614/* harmony export */ hydrateOnInteraction: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.hydrateOnInteraction), 17615/* harmony export */ hydrateOnMediaQuery: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.hydrateOnMediaQuery), 17616/* harmony export */ hydrateOnVisible: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.hydrateOnVisible), 17617/* harmony export */ initCustomFormatter: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.initCustomFormatter), 17618/* harmony export */ initDirectivesForSSR: () => (/* binding */ initDirectivesForSSR), 17619/* harmony export */ inject: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.inject), 17620/* harmony export */ isMemoSame: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isMemoSame), 17621/* harmony export */ isProxy: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isProxy), 17622/* harmony export */ isReactive: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isReactive), 17623/* harmony export */ isReadonly: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isReadonly), 17624/* harmony export */ isRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isRef), 17625/* harmony export */ isRuntimeOnly: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly), 17626/* harmony export */ isShallow: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isShallow), 17627/* harmony export */ isVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isVNode), 17628/* harmony export */ markRaw: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.markRaw), 17629/* harmony export */ mergeDefaults: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.mergeDefaults), 17630/* harmony export */ mergeModels: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.mergeModels), 17631/* harmony export */ mergeProps: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.mergeProps), 17632/* harmony export */ nextTick: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.nextTick), 17633/* harmony export */ normalizeClass: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.normalizeClass), 17634/* harmony export */ normalizeProps: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.normalizeProps), 17635/* harmony export */ normalizeStyle: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle), 17636/* harmony export */ onActivated: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onActivated), 17637/* harmony export */ onBeforeMount: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount), 17638/* harmony export */ onBeforeUnmount: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount), 17639/* harmony export */ onBeforeUpdate: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeUpdate), 17640/* harmony export */ onDeactivated: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onDeactivated), 17641/* harmony export */ onErrorCaptured: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onErrorCaptured), 17642/* harmony export */ onMounted: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onMounted), 17643/* harmony export */ onRenderTracked: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onRenderTracked), 17644/* harmony export */ onRenderTriggered: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onRenderTriggered), 17645/* harmony export */ onScopeDispose: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose), 17646/* harmony export */ onServerPrefetch: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onServerPrefetch), 17647/* harmony export */ onUnmounted: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUnmounted), 17648/* harmony export */ onUpdated: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUpdated), 17649/* harmony export */ onWatcherCleanup: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onWatcherCleanup), 17650/* harmony export */ openBlock: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.openBlock), 17651/* harmony export */ popScopeId: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.popScopeId), 17652/* harmony export */ provide: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.provide), 17653/* harmony export */ proxyRefs: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.proxyRefs), 17654/* harmony export */ pushScopeId: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.pushScopeId), 17655/* harmony export */ queuePostFlushCb: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.queuePostFlushCb), 17656/* harmony export */ reactive: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.reactive), 17657/* harmony export */ readonly: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.readonly), 17658/* harmony export */ ref: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ref), 17659/* harmony export */ registerRuntimeCompiler: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeCompiler), 17660/* harmony export */ render: () => (/* binding */ render), 17661/* harmony export */ renderList: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.renderList), 17662/* harmony export */ renderSlot: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.renderSlot), 17663/* harmony export */ resolveComponent: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveComponent), 17664/* harmony export */ resolveDirective: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveDirective), 17665/* harmony export */ resolveDynamicComponent: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent), 17666/* harmony export */ resolveFilter: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveFilter), 17667/* harmony export */ resolveTransitionHooks: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks), 17668/* harmony export */ setBlockTracking: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setBlockTracking), 17669/* harmony export */ setDevtoolsHook: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setDevtoolsHook), 17670/* harmony export */ setTransitionHooks: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks), 17671/* harmony export */ shallowReactive: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.shallowReactive), 17672/* harmony export */ shallowReadonly: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly), 17673/* harmony export */ shallowRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.shallowRef), 17674/* harmony export */ ssrContextKey: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ssrContextKey), 17675/* harmony export */ ssrUtils: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ssrUtils), 17676/* harmony export */ stop: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.stop), 17677/* harmony export */ toDisplayString: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toDisplayString), 17678/* harmony export */ toHandlerKey: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey), 17679/* harmony export */ toHandlers: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toHandlers), 17680/* harmony export */ toRaw: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toRaw), 17681/* harmony export */ toRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toRef), 17682/* harmony export */ toRefs: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toRefs), 17683/* harmony export */ toValue: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toValue), 17684/* harmony export */ transformVNodeArgs: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.transformVNodeArgs), 17685/* harmony export */ triggerRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.triggerRef), 17686/* harmony export */ unref: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.unref), 17687/* harmony export */ useAttrs: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useAttrs), 17688/* harmony export */ useCssModule: () => (/* binding */ useCssModule), 17689/* harmony export */ useCssVars: () => (/* binding */ useCssVars), 17690/* harmony export */ useHost: () => (/* binding */ useHost), 17691/* harmony export */ useId: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useId), 17692/* harmony export */ useModel: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useModel), 17693/* harmony export */ useSSRContext: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useSSRContext), 17694/* harmony export */ useShadowRoot: () => (/* binding */ useShadowRoot), 17695/* harmony export */ useSlots: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useSlots), 17696/* harmony export */ useTemplateRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useTemplateRef), 17697/* harmony export */ useTransitionState: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useTransitionState), 17698/* harmony export */ vModelCheckbox: () => (/* binding */ vModelCheckbox), 17699/* harmony export */ vModelDynamic: () => (/* binding */ vModelDynamic), 17700/* harmony export */ vModelRadio: () => (/* binding */ vModelRadio), 17701/* harmony export */ vModelSelect: () => (/* binding */ vModelSelect), 17702/* harmony export */ vModelText: () => (/* binding */ vModelText), 17703/* harmony export */ vShow: () => (/* binding */ vShow), 17704/* harmony export */ version: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.version), 17705/* harmony export */ warn: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn), 17706/* harmony export */ watch: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watch), 17707/* harmony export */ watchEffect: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchEffect), 17708/* harmony export */ watchPostEffect: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchPostEffect), 17709/* harmony export */ watchSyncEffect: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchSyncEffect), 17710/* harmony export */ withAsyncContext: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withAsyncContext), 17711/* harmony export */ withCtx: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withCtx), 17712/* harmony export */ withDefaults: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withDefaults), 17713/* harmony export */ withDirectives: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withDirectives), 17714/* harmony export */ withKeys: () => (/* binding */ withKeys), 17715/* harmony export */ withMemo: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withMemo), 17716/* harmony export */ withModifiers: () => (/* binding */ withModifiers), 17717/* harmony export */ withScopeId: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withScopeId) 17718/* harmony export */ }); 17719/* harmony import */ var _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/runtime-core */ "./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js"); 17720/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 17721/* harmony import */ var _vue_runtime_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @vue/runtime-core */ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js"); 17722/** 17723* @vue/runtime-dom v3.5.13 17724* (c) 2018-present Yuxi (Evan) You and Vue contributors 17725* @license MIT 17726**/ 17727 17728 17729 17730 17731let policy = void 0; 17732const tt = typeof window !== "undefined" && window.trustedTypes; 17733if (tt) { 17734 try { 17735 policy = /* @__PURE__ */ tt.createPolicy("vue", { 17736 createHTML: (val) => val 17737 }); 17738 } catch (e) { 17739 true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Error creating trusted types policy: ${e}`); 17740 } 17741} 17742const unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val; 17743const svgNS = "http://www.w3.org/2000/svg"; 17744const mathmlNS = "http://www.w3.org/1998/Math/MathML"; 17745const doc = typeof document !== "undefined" ? document : null; 17746const templateContainer = doc && /* @__PURE__ */ doc.createElement("template"); 17747const nodeOps = { 17748 insert: (child, parent, anchor) => { 17749 parent.insertBefore(child, anchor || null); 17750 }, 17751 remove: (child) => { 17752 const parent = child.parentNode; 17753 if (parent) { 17754 parent.removeChild(child); 17755 } 17756 }, 17757 createElement: (tag, namespace, is, props) => { 17758 const el = namespace === "svg" ? doc.createElementNS(svgNS, tag) : namespace === "mathml" ? doc.createElementNS(mathmlNS, tag) : is ? doc.createElement(tag, { is }) : doc.createElement(tag); 17759 if (tag === "select" && props && props.multiple != null) { 17760 el.setAttribute("multiple", props.multiple); 17761 } 17762 return el; 17763 }, 17764 createText: (text) => doc.createTextNode(text), 17765 createComment: (text) => doc.createComment(text), 17766 setText: (node, text) => { 17767 node.nodeValue = text; 17768 }, 17769 setElementText: (el, text) => { 17770 el.textContent = text; 17771 }, 17772 parentNode: (node) => node.parentNode, 17773 nextSibling: (node) => node.nextSibling, 17774 querySelector: (selector) => doc.querySelector(selector), 17775 setScopeId(el, id) { 17776 el.setAttribute(id, ""); 17777 }, 17778 // __UNSAFE__ 17779 // Reason: innerHTML. 17780 // Static content here can only come from compiled templates. 17781 // As long as the user only uses trusted templates, this is safe. 17782 insertStaticContent(content, parent, anchor, namespace, start, end) { 17783 const before = anchor ? anchor.previousSibling : parent.lastChild; 17784 if (start && (start === end || start.nextSibling)) { 17785 while (true) { 17786 parent.insertBefore(start.cloneNode(true), anchor); 17787 if (start === end || !(start = start.nextSibling)) break; 17788 } 17789 } else { 17790 templateContainer.innerHTML = unsafeToTrustedHTML( 17791 namespace === "svg" ? `<svg>${content}</svg>` : namespace === "mathml" ? `<math>${content}</math>` : content 17792 ); 17793 const template = templateContainer.content; 17794 if (namespace === "svg" || namespace === "mathml") { 17795 const wrapper = template.firstChild; 17796 while (wrapper.firstChild) { 17797 template.appendChild(wrapper.firstChild); 17798 } 17799 template.removeChild(wrapper); 17800 } 17801 parent.insertBefore(template, anchor); 17802 } 17803 return [ 17804 // first 17805 before ? before.nextSibling : parent.firstChild, 17806 // last 17807 anchor ? anchor.previousSibling : parent.lastChild 17808 ]; 17809 } 17810}; 17811 17812const TRANSITION = "transition"; 17813const ANIMATION = "animation"; 17814const vtcKey = Symbol("_vtc"); 17815const DOMTransitionPropsValidators = { 17816 name: String, 17817 type: String, 17818 css: { 17819 type: Boolean, 17820 default: true 17821 }, 17822 duration: [String, Number, Object], 17823 enterFromClass: String, 17824 enterActiveClass: String, 17825 enterToClass: String, 17826 appearFromClass: String, 17827 appearActiveClass: String, 17828 appearToClass: String, 17829 leaveFromClass: String, 17830 leaveActiveClass: String, 17831 leaveToClass: String 17832}; 17833const TransitionPropsValidators = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)( 17834 {}, 17835 _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransitionPropsValidators, 17836 DOMTransitionPropsValidators 17837); 17838const decorate$1 = (t) => { 17839 t.displayName = "Transition"; 17840 t.props = TransitionPropsValidators; 17841 return t; 17842}; 17843const Transition = /* @__PURE__ */ decorate$1( 17844 (props, { slots }) => (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.h)(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransition, resolveTransitionProps(props), slots) 17845); 17846const callHook = (hook, args = []) => { 17847 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook)) { 17848 hook.forEach((h2) => h2(...args)); 17849 } else if (hook) { 17850 hook(...args); 17851 } 17852}; 17853const hasExplicitCallback = (hook) => { 17854 return hook ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false; 17855}; 17856function resolveTransitionProps(rawProps) { 17857 const baseProps = {}; 17858 for (const key in rawProps) { 17859 if (!(key in DOMTransitionPropsValidators)) { 17860 baseProps[key] = rawProps[key]; 17861 } 17862 } 17863 if (rawProps.css === false) { 17864 return baseProps; 17865 } 17866 const { 17867 name = "v", 17868 type, 17869 duration, 17870 enterFromClass = `${name}-enter-from`, 17871 enterActiveClass = `${name}-enter-active`, 17872 enterToClass = `${name}-enter-to`, 17873 appearFromClass = enterFromClass, 17874 appearActiveClass = enterActiveClass, 17875 appearToClass = enterToClass, 17876 leaveFromClass = `${name}-leave-from`, 17877 leaveActiveClass = `${name}-leave-active`, 17878 leaveToClass = `${name}-leave-to` 17879 } = rawProps; 17880 const durations = normalizeDuration(duration); 17881 const enterDuration = durations && durations[0]; 17882 const leaveDuration = durations && durations[1]; 17883 const { 17884 onBeforeEnter, 17885 onEnter, 17886 onEnterCancelled, 17887 onLeave, 17888 onLeaveCancelled, 17889 onBeforeAppear = onBeforeEnter, 17890 onAppear = onEnter, 17891 onAppearCancelled = onEnterCancelled 17892 } = baseProps; 17893 const finishEnter = (el, isAppear, done, isCancelled) => { 17894 el._enterCancelled = isCancelled; 17895 removeTransitionClass(el, isAppear ? appearToClass : enterToClass); 17896 removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass); 17897 done && done(); 17898 }; 17899 const finishLeave = (el, done) => { 17900 el._isLeaving = false; 17901 removeTransitionClass(el, leaveFromClass); 17902 removeTransitionClass(el, leaveToClass); 17903 removeTransitionClass(el, leaveActiveClass); 17904 done && done(); 17905 }; 17906 const makeEnterHook = (isAppear) => { 17907 return (el, done) => { 17908 const hook = isAppear ? onAppear : onEnter; 17909 const resolve = () => finishEnter(el, isAppear, done); 17910 callHook(hook, [el, resolve]); 17911 nextFrame(() => { 17912 removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass); 17913 addTransitionClass(el, isAppear ? appearToClass : enterToClass); 17914 if (!hasExplicitCallback(hook)) { 17915 whenTransitionEnds(el, type, enterDuration, resolve); 17916 } 17917 }); 17918 }; 17919 }; 17920 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(baseProps, { 17921 onBeforeEnter(el) { 17922 callHook(onBeforeEnter, [el]); 17923 addTransitionClass(el, enterFromClass); 17924 addTransitionClass(el, enterActiveClass); 17925 }, 17926 onBeforeAppear(el) { 17927 callHook(onBeforeAppear, [el]); 17928 addTransitionClass(el, appearFromClass); 17929 addTransitionClass(el, appearActiveClass); 17930 }, 17931 onEnter: makeEnterHook(false), 17932 onAppear: makeEnterHook(true), 17933 onLeave(el, done) { 17934 el._isLeaving = true; 17935 const resolve = () => finishLeave(el, done); 17936 addTransitionClass(el, leaveFromClass); 17937 if (!el._enterCancelled) { 17938 forceReflow(); 17939 addTransitionClass(el, leaveActiveClass); 17940 } else { 17941 addTransitionClass(el, leaveActiveClass); 17942 forceReflow(); 17943 } 17944 nextFrame(() => { 17945 if (!el._isLeaving) { 17946 return; 17947 } 17948 removeTransitionClass(el, leaveFromClass); 17949 addTransitionClass(el, leaveToClass); 17950 if (!hasExplicitCallback(onLeave)) { 17951 whenTransitionEnds(el, type, leaveDuration, resolve); 17952 } 17953 }); 17954 callHook(onLeave, [el, resolve]); 17955 }, 17956 onEnterCancelled(el) { 17957 finishEnter(el, false, void 0, true); 17958 callHook(onEnterCancelled, [el]); 17959 }, 17960 onAppearCancelled(el) { 17961 finishEnter(el, true, void 0, true); 17962 callHook(onAppearCancelled, [el]); 17963 }, 17964 onLeaveCancelled(el) { 17965 finishLeave(el); 17966 callHook(onLeaveCancelled, [el]); 17967 } 17968 }); 17969} 17970function normalizeDuration(duration) { 17971 if (duration == null) { 17972 return null; 17973 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(duration)) { 17974 return [NumberOf(duration.enter), NumberOf(duration.leave)]; 17975 } else { 17976 const n = NumberOf(duration); 17977 return [n, n]; 17978 } 17979} 17980function NumberOf(val) { 17981 const res = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(val); 17982 if (true) { 17983 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.assertNumber)(res, "<transition> explicit duration"); 17984 } 17985 return res; 17986} 17987function addTransitionClass(el, cls) { 17988 cls.split(/\s+/).forEach((c) => c && el.classList.add(c)); 17989 (el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls); 17990} 17991function removeTransitionClass(el, cls) { 17992 cls.split(/\s+/).forEach((c) => c && el.classList.remove(c)); 17993 const _vtc = el[vtcKey]; 17994 if (_vtc) { 17995 _vtc.delete(cls); 17996 if (!_vtc.size) { 17997 el[vtcKey] = void 0; 17998 } 17999 } 18000} 18001function nextFrame(cb) { 18002 requestAnimationFrame(() => { 18003 requestAnimationFrame(cb); 18004 }); 18005} 18006let endId = 0; 18007function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) { 18008 const id = el._endId = ++endId; 18009 const resolveIfNotStale = () => { 18010 if (id === el._endId) { 18011 resolve(); 18012 } 18013 }; 18014 if (explicitTimeout != null) { 18015 return setTimeout(resolveIfNotStale, explicitTimeout); 18016 } 18017 const { type, timeout, propCount } = getTransitionInfo(el, expectedType); 18018 if (!type) { 18019 return resolve(); 18020 } 18021 const endEvent = type + "end"; 18022 let ended = 0; 18023 const end = () => { 18024 el.removeEventListener(endEvent, onEnd); 18025 resolveIfNotStale(); 18026 }; 18027 const onEnd = (e) => { 18028 if (e.target === el && ++ended >= propCount) { 18029 end(); 18030 } 18031 }; 18032 setTimeout(() => { 18033 if (ended < propCount) { 18034 end(); 18035 } 18036 }, timeout + 1); 18037 el.addEventListener(endEvent, onEnd); 18038} 18039function getTransitionInfo(el, expectedType) { 18040 const styles = window.getComputedStyle(el); 18041 const getStyleProperties = (key) => (styles[key] || "").split(", "); 18042 const transitionDelays = getStyleProperties(`${TRANSITION}Delay`); 18043 const transitionDurations = getStyleProperties(`${TRANSITION}Duration`); 18044 const transitionTimeout = getTimeout(transitionDelays, transitionDurations); 18045 const animationDelays = getStyleProperties(`${ANIMATION}Delay`); 18046 const animationDurations = getStyleProperties(`${ANIMATION}Duration`); 18047 const animationTimeout = getTimeout(animationDelays, animationDurations); 18048 let type = null; 18049 let timeout = 0; 18050 let propCount = 0; 18051 if (expectedType === TRANSITION) { 18052 if (transitionTimeout > 0) { 18053 type = TRANSITION; 18054 timeout = transitionTimeout; 18055 propCount = transitionDurations.length; 18056 } 18057 } else if (expectedType === ANIMATION) { 18058 if (animationTimeout > 0) { 18059 type = ANIMATION; 18060 timeout = animationTimeout; 18061 propCount = animationDurations.length; 18062 } 18063 } else { 18064 timeout = Math.max(transitionTimeout, animationTimeout); 18065 type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null; 18066 propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0; 18067 } 18068 const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test( 18069 getStyleProperties(`${TRANSITION}Property`).toString() 18070 ); 18071 return { 18072 type, 18073 timeout, 18074 propCount, 18075 hasTransform 18076 }; 18077} 18078function getTimeout(delays, durations) { 18079 while (delays.length < durations.length) { 18080 delays = delays.concat(delays); 18081 } 18082 return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i]))); 18083} 18084function toMs(s) { 18085 if (s === "auto") return 0; 18086 return Number(s.slice(0, -1).replace(",", ".")) * 1e3; 18087} 18088function forceReflow() { 18089 return document.body.offsetHeight; 18090} 18091 18092function patchClass(el, value, isSVG) { 18093 const transitionClasses = el[vtcKey]; 18094 if (transitionClasses) { 18095 value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" "); 18096 } 18097 if (value == null) { 18098 el.removeAttribute("class"); 18099 } else if (isSVG) { 18100 el.setAttribute("class", value); 18101 } else { 18102 el.className = value; 18103 } 18104} 18105 18106const vShowOriginalDisplay = Symbol("_vod"); 18107const vShowHidden = Symbol("_vsh"); 18108const vShow = { 18109 beforeMount(el, { value }, { transition }) { 18110 el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display; 18111 if (transition && value) { 18112 transition.beforeEnter(el); 18113 } else { 18114 setDisplay(el, value); 18115 } 18116 }, 18117 mounted(el, { value }, { transition }) { 18118 if (transition && value) { 18119 transition.enter(el); 18120 } 18121 }, 18122 updated(el, { value, oldValue }, { transition }) { 18123 if (!value === !oldValue) return; 18124 if (transition) { 18125 if (value) { 18126 transition.beforeEnter(el); 18127 setDisplay(el, true); 18128 transition.enter(el); 18129 } else { 18130 transition.leave(el, () => { 18131 setDisplay(el, false); 18132 }); 18133 } 18134 } else { 18135 setDisplay(el, value); 18136 } 18137 }, 18138 beforeUnmount(el, { value }) { 18139 setDisplay(el, value); 18140 } 18141}; 18142if (true) { 18143 vShow.name = "show"; 18144} 18145function setDisplay(el, value) { 18146 el.style.display = value ? el[vShowOriginalDisplay] : "none"; 18147 el[vShowHidden] = !value; 18148} 18149function initVShowForSSR() { 18150 vShow.getSSRProps = ({ value }) => { 18151 if (!value) { 18152 return { style: { display: "none" } }; 18153 } 18154 }; 18155} 18156 18157const CSS_VAR_TEXT = Symbol( true ? "CSS_VAR_TEXT" : 0); 18158function useCssVars(getter) { 18159 const instance = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)(); 18160 if (!instance) { 18161 true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`useCssVars is called without current active component instance.`); 18162 return; 18163 } 18164 const updateTeleports = instance.ut = (vars = getter(instance.proxy)) => { 18165 Array.from( 18166 document.querySelectorAll(`[data-v-owner="${instance.uid}"]`) 18167 ).forEach((node) => setVarsOnNode(node, vars)); 18168 }; 18169 if (true) { 18170 instance.getCssVars = () => getter(instance.proxy); 18171 } 18172 const setVars = () => { 18173 const vars = getter(instance.proxy); 18174 if (instance.ce) { 18175 setVarsOnNode(instance.ce, vars); 18176 } else { 18177 setVarsOnVNode(instance.subTree, vars); 18178 } 18179 updateTeleports(vars); 18180 }; 18181 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeUpdate)(() => { 18182 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.queuePostFlushCb)(setVars); 18183 }); 18184 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => { 18185 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watch)(setVars, _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP, { flush: "post" }); 18186 const ob = new MutationObserver(setVars); 18187 ob.observe(instance.subTree.el.parentNode, { childList: true }); 18188 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => ob.disconnect()); 18189 }); 18190} 18191function setVarsOnVNode(vnode, vars) { 18192 if (vnode.shapeFlag & 128) { 18193 const suspense = vnode.suspense; 18194 vnode = suspense.activeBranch; 18195 if (suspense.pendingBranch && !suspense.isHydrating) { 18196 suspense.effects.push(() => { 18197 setVarsOnVNode(suspense.activeBranch, vars); 18198 }); 18199 } 18200 } 18201 while (vnode.component) { 18202 vnode = vnode.component.subTree; 18203 } 18204 if (vnode.shapeFlag & 1 && vnode.el) { 18205 setVarsOnNode(vnode.el, vars); 18206 } else if (vnode.type === _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Fragment) { 18207 vnode.children.forEach((c) => setVarsOnVNode(c, vars)); 18208 } else if (vnode.type === _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Static) { 18209 let { el, anchor } = vnode; 18210 while (el) { 18211 setVarsOnNode(el, vars); 18212 if (el === anchor) break; 18213 el = el.nextSibling; 18214 } 18215 } 18216} 18217function setVarsOnNode(el, vars) { 18218 if (el.nodeType === 1) { 18219 const style = el.style; 18220 let cssText = ""; 18221 for (const key in vars) { 18222 style.setProperty(`--${key}`, vars[key]); 18223 cssText += `--${key}: ${vars[key]};`; 18224 } 18225 style[CSS_VAR_TEXT] = cssText; 18226 } 18227} 18228 18229const displayRE = /(^|;)\s*display\s*:/; 18230function patchStyle(el, prev, next) { 18231 const style = el.style; 18232 const isCssString = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(next); 18233 let hasControlledDisplay = false; 18234 if (next && !isCssString) { 18235 if (prev) { 18236 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(prev)) { 18237 for (const key in prev) { 18238 if (next[key] == null) { 18239 setStyle(style, key, ""); 18240 } 18241 } 18242 } else { 18243 for (const prevStyle of prev.split(";")) { 18244 const key = prevStyle.slice(0, prevStyle.indexOf(":")).trim(); 18245 if (next[key] == null) { 18246 setStyle(style, key, ""); 18247 } 18248 } 18249 } 18250 } 18251 for (const key in next) { 18252 if (key === "display") { 18253 hasControlledDisplay = true; 18254 } 18255 setStyle(style, key, next[key]); 18256 } 18257 } else { 18258 if (isCssString) { 18259 if (prev !== next) { 18260 const cssVarText = style[CSS_VAR_TEXT]; 18261 if (cssVarText) { 18262 next += ";" + cssVarText; 18263 } 18264 style.cssText = next; 18265 hasControlledDisplay = displayRE.test(next); 18266 } 18267 } else if (prev) { 18268 el.removeAttribute("style"); 18269 } 18270 } 18271 if (vShowOriginalDisplay in el) { 18272 el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : ""; 18273 if (el[vShowHidden]) { 18274 style.display = "none"; 18275 } 18276 } 18277} 18278const semicolonRE = /[^\\];\s*$/; 18279const importantRE = /\s*!important$/; 18280function setStyle(style, name, val) { 18281 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(val)) { 18282 val.forEach((v) => setStyle(style, name, v)); 18283 } else { 18284 if (val == null) val = ""; 18285 if (true) { 18286 if (semicolonRE.test(val)) { 18287 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 18288 `Unexpected semicolon at the end of '${name}' style value: '${val}'` 18289 ); 18290 } 18291 } 18292 if (name.startsWith("--")) { 18293 style.setProperty(name, val); 18294 } else { 18295 const prefixed = autoPrefix(style, name); 18296 if (importantRE.test(val)) { 18297 style.setProperty( 18298 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(prefixed), 18299 val.replace(importantRE, ""), 18300 "important" 18301 ); 18302 } else { 18303 style[prefixed] = val; 18304 } 18305 } 18306 } 18307} 18308const prefixes = ["Webkit", "Moz", "ms"]; 18309const prefixCache = {}; 18310function autoPrefix(style, rawName) { 18311 const cached = prefixCache[rawName]; 18312 if (cached) { 18313 return cached; 18314 } 18315 let name = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(rawName); 18316 if (name !== "filter" && name in style) { 18317 return prefixCache[rawName] = name; 18318 } 18319 name = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)(name); 18320 for (let i = 0; i < prefixes.length; i++) { 18321 const prefixed = prefixes[i] + name; 18322 if (prefixed in style) { 18323 return prefixCache[rawName] = prefixed; 18324 } 18325 } 18326 return rawName; 18327} 18328 18329const xlinkNS = "http://www.w3.org/1999/xlink"; 18330function patchAttr(el, key, value, isSVG, instance, isBoolean = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSpecialBooleanAttr)(key)) { 18331 if (isSVG && key.startsWith("xlink:")) { 18332 if (value == null) { 18333 el.removeAttributeNS(xlinkNS, key.slice(6, key.length)); 18334 } else { 18335 el.setAttributeNS(xlinkNS, key, value); 18336 } 18337 } else { 18338 if (value == null || isBoolean && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.includeBooleanAttr)(value)) { 18339 el.removeAttribute(key); 18340 } else { 18341 el.setAttribute( 18342 key, 18343 isBoolean ? "" : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSymbol)(value) ? String(value) : value 18344 ); 18345 } 18346 } 18347} 18348 18349function patchDOMProp(el, key, value, parentComponent, attrName) { 18350 if (key === "innerHTML" || key === "textContent") { 18351 if (value != null) { 18352 el[key] = key === "innerHTML" ? unsafeToTrustedHTML(value) : value; 18353 } 18354 return; 18355 } 18356 const tag = el.tagName; 18357 if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally 18358 !tag.includes("-")) { 18359 const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value; 18360 const newValue = value == null ? ( 18361 // #11647: value should be set as empty string for null and undefined, 18362 // but <input type="checkbox"> should be set as 'on'. 18363 el.type === "checkbox" ? "on" : "" 18364 ) : String(value); 18365 if (oldValue !== newValue || !("_value" in el)) { 18366 el.value = newValue; 18367 } 18368 if (value == null) { 18369 el.removeAttribute(key); 18370 } 18371 el._value = value; 18372 return; 18373 } 18374 let needRemove = false; 18375 if (value === "" || value == null) { 18376 const type = typeof el[key]; 18377 if (type === "boolean") { 18378 value = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.includeBooleanAttr)(value); 18379 } else if (value == null && type === "string") { 18380 value = ""; 18381 needRemove = true; 18382 } else if (type === "number") { 18383 value = 0; 18384 needRemove = true; 18385 } 18386 } 18387 try { 18388 el[key] = value; 18389 } catch (e) { 18390 if ( true && !needRemove) { 18391 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 18392 `Failed setting prop "${key}" on <${tag.toLowerCase()}>: value ${value} is invalid.`, 18393 e 18394 ); 18395 } 18396 } 18397 needRemove && el.removeAttribute(attrName || key); 18398} 18399 18400function addEventListener(el, event, handler, options) { 18401 el.addEventListener(event, handler, options); 18402} 18403function removeEventListener(el, event, handler, options) { 18404 el.removeEventListener(event, handler, options); 18405} 18406const veiKey = Symbol("_vei"); 18407function patchEvent(el, rawName, prevValue, nextValue, instance = null) { 18408 const invokers = el[veiKey] || (el[veiKey] = {}); 18409 const existingInvoker = invokers[rawName]; 18410 if (nextValue && existingInvoker) { 18411 existingInvoker.value = true ? sanitizeEventValue(nextValue, rawName) : 0; 18412 } else { 18413 const [name, options] = parseName(rawName); 18414 if (nextValue) { 18415 const invoker = invokers[rawName] = createInvoker( 18416 true ? sanitizeEventValue(nextValue, rawName) : 0, 18417 instance 18418 ); 18419 addEventListener(el, name, invoker, options); 18420 } else if (existingInvoker) { 18421 removeEventListener(el, name, existingInvoker, options); 18422 invokers[rawName] = void 0; 18423 } 18424 } 18425} 18426const optionsModifierRE = /(?:Once|Passive|Capture)$/; 18427function parseName(name) { 18428 let options; 18429 if (optionsModifierRE.test(name)) { 18430 options = {}; 18431 let m; 18432 while (m = name.match(optionsModifierRE)) { 18433 name = name.slice(0, name.length - m[0].length); 18434 options[m[0].toLowerCase()] = true; 18435 } 18436 } 18437 const event = name[2] === ":" ? name.slice(3) : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(name.slice(2)); 18438 return [event, options]; 18439} 18440let cachedNow = 0; 18441const p = /* @__PURE__ */ Promise.resolve(); 18442const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now()); 18443function createInvoker(initialValue, instance) { 18444 const invoker = (e) => { 18445 if (!e._vts) { 18446 e._vts = Date.now(); 18447 } else if (e._vts <= invoker.attached) { 18448 return; 18449 } 18450 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling)( 18451 patchStopImmediatePropagation(e, invoker.value), 18452 instance, 18453 5, 18454 [e] 18455 ); 18456 }; 18457 invoker.value = initialValue; 18458 invoker.attached = getNow(); 18459 return invoker; 18460} 18461function sanitizeEventValue(value, propName) { 18462 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) { 18463 return value; 18464 } 18465 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 18466 `Wrong type passed as event handler to ${propName} - did you forget @ or : in front of your prop? 18467Expected function or array of functions, received type ${typeof value}.` 18468 ); 18469 return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP; 18470} 18471function patchStopImmediatePropagation(e, value) { 18472 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) { 18473 const originalStop = e.stopImmediatePropagation; 18474 e.stopImmediatePropagation = () => { 18475 originalStop.call(e); 18476 e._stopped = true; 18477 }; 18478 return value.map( 18479 (fn) => (e2) => !e2._stopped && fn && fn(e2) 18480 ); 18481 } else { 18482 return value; 18483 } 18484} 18485 18486const isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // lowercase letter 18487key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123; 18488const patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) => { 18489 const isSVG = namespace === "svg"; 18490 if (key === "class") { 18491 patchClass(el, nextValue, isSVG); 18492 } else if (key === "style") { 18493 patchStyle(el, prevValue, nextValue); 18494 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) { 18495 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)(key)) { 18496 patchEvent(el, key, prevValue, nextValue, parentComponent); 18497 } 18498 } else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) { 18499 patchDOMProp(el, key, nextValue); 18500 if (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) { 18501 patchAttr(el, key, nextValue, isSVG, parentComponent, key !== "value"); 18502 } 18503 } else if ( 18504 // #11081 force set props for possible async custom element 18505 el._isVueCE && (/[A-Z]/.test(key) || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(nextValue)) 18506 ) { 18507 patchDOMProp(el, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key), nextValue, parentComponent, key); 18508 } else { 18509 if (key === "true-value") { 18510 el._trueValue = nextValue; 18511 } else if (key === "false-value") { 18512 el._falseValue = nextValue; 18513 } 18514 patchAttr(el, key, nextValue, isSVG); 18515 } 18516}; 18517function shouldSetAsProp(el, key, value, isSVG) { 18518 if (isSVG) { 18519 if (key === "innerHTML" || key === "textContent") { 18520 return true; 18521 } 18522 if (key in el && isNativeOn(key) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) { 18523 return true; 18524 } 18525 return false; 18526 } 18527 if (key === "spellcheck" || key === "draggable" || key === "translate") { 18528 return false; 18529 } 18530 if (key === "form") { 18531 return false; 18532 } 18533 if (key === "list" && el.tagName === "INPUT") { 18534 return false; 18535 } 18536 if (key === "type" && el.tagName === "TEXTAREA") { 18537 return false; 18538 } 18539 if (key === "width" || key === "height") { 18540 const tag = el.tagName; 18541 if (tag === "IMG" || tag === "VIDEO" || tag === "CANVAS" || tag === "SOURCE") { 18542 return false; 18543 } 18544 } 18545 if (isNativeOn(key) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(value)) { 18546 return false; 18547 } 18548 return key in el; 18549} 18550 18551const REMOVAL = {}; 18552/*! #__NO_SIDE_EFFECTS__ */ 18553// @__NO_SIDE_EFFECTS__ 18554function defineCustomElement(options, extraOptions, _createApp) { 18555 const Comp = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineComponent)(options, extraOptions); 18556 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPlainObject)(Comp)) (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(Comp, extraOptions); 18557 class VueCustomElement extends VueElement { 18558 constructor(initialProps) { 18559 super(Comp, initialProps, _createApp); 18560 } 18561 } 18562 VueCustomElement.def = Comp; 18563 return VueCustomElement; 18564} 18565/*! #__NO_SIDE_EFFECTS__ */ 18566const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options, extraOptions) => { 18567 return /* @__PURE__ */ defineCustomElement(options, extraOptions, createSSRApp); 18568}; 18569const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class { 18570}; 18571class VueElement extends BaseClass { 18572 constructor(_def, _props = {}, _createApp = createApp) { 18573 super(); 18574 this._def = _def; 18575 this._props = _props; 18576 this._createApp = _createApp; 18577 this._isVueCE = true; 18578 /** 18579 * @internal 18580 */ 18581 this._instance = null; 18582 /** 18583 * @internal 18584 */ 18585 this._app = null; 18586 /** 18587 * @internal 18588 */ 18589 this._nonce = this._def.nonce; 18590 this._connected = false; 18591 this._resolved = false; 18592 this._numberProps = null; 18593 this._styleChildren = /* @__PURE__ */ new WeakSet(); 18594 this._ob = null; 18595 if (this.shadowRoot && _createApp !== createApp) { 18596 this._root = this.shadowRoot; 18597 } else { 18598 if ( true && this.shadowRoot) { 18599 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 18600 `Custom element has pre-rendered declarative shadow root but is not defined as hydratable. Use \`defineSSRCustomElement\`.` 18601 ); 18602 } 18603 if (_def.shadowRoot !== false) { 18604 this.attachShadow({ mode: "open" }); 18605 this._root = this.shadowRoot; 18606 } else { 18607 this._root = this; 18608 } 18609 } 18610 if (!this._def.__asyncLoader) { 18611 this._resolveProps(this._def); 18612 } 18613 } 18614 connectedCallback() { 18615 if (!this.isConnected) return; 18616 if (!this.shadowRoot) { 18617 this._parseSlots(); 18618 } 18619 this._connected = true; 18620 let parent = this; 18621 while (parent = parent && (parent.parentNode || parent.host)) { 18622 if (parent instanceof VueElement) { 18623 this._parent = parent; 18624 break; 18625 } 18626 } 18627 if (!this._instance) { 18628 if (this._resolved) { 18629 this._setParent(); 18630 this._update(); 18631 } else { 18632 if (parent && parent._pendingResolve) { 18633 this._pendingResolve = parent._pendingResolve.then(() => { 18634 this._pendingResolve = void 0; 18635 this._resolveDef(); 18636 }); 18637 } else { 18638 this._resolveDef(); 18639 } 18640 } 18641 } 18642 } 18643 _setParent(parent = this._parent) { 18644 if (parent) { 18645 this._instance.parent = parent._instance; 18646 this._instance.provides = parent._instance.provides; 18647 } 18648 } 18649 disconnectedCallback() { 18650 this._connected = false; 18651 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => { 18652 if (!this._connected) { 18653 if (this._ob) { 18654 this._ob.disconnect(); 18655 this._ob = null; 18656 } 18657 this._app && this._app.unmount(); 18658 if (this._instance) this._instance.ce = void 0; 18659 this._app = this._instance = null; 18660 } 18661 }); 18662 } 18663 /** 18664 * resolve inner component definition (handle possible async component) 18665 */ 18666 _resolveDef() { 18667 if (this._pendingResolve) { 18668 return; 18669 } 18670 for (let i = 0; i < this.attributes.length; i++) { 18671 this._setAttr(this.attributes[i].name); 18672 } 18673 this._ob = new MutationObserver((mutations) => { 18674 for (const m of mutations) { 18675 this._setAttr(m.attributeName); 18676 } 18677 }); 18678 this._ob.observe(this, { attributes: true }); 18679 const resolve = (def, isAsync = false) => { 18680 this._resolved = true; 18681 this._pendingResolve = void 0; 18682 const { props, styles } = def; 18683 let numberProps; 18684 if (props && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(props)) { 18685 for (const key in props) { 18686 const opt = props[key]; 18687 if (opt === Number || opt && opt.type === Number) { 18688 if (key in this._props) { 18689 this._props[key] = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(this._props[key]); 18690 } 18691 (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key)] = true; 18692 } 18693 } 18694 } 18695 this._numberProps = numberProps; 18696 if (isAsync) { 18697 this._resolveProps(def); 18698 } 18699 if (this.shadowRoot) { 18700 this._applyStyles(styles); 18701 } else if ( true && styles) { 18702 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 18703 "Custom element style injection is not supported when using shadowRoot: false" 18704 ); 18705 } 18706 this._mount(def); 18707 }; 18708 const asyncDef = this._def.__asyncLoader; 18709 if (asyncDef) { 18710 this._pendingResolve = asyncDef().then( 18711 (def) => resolve(this._def = def, true) 18712 ); 18713 } else { 18714 resolve(this._def); 18715 } 18716 } 18717 _mount(def) { 18718 if (( true) && !def.name) { 18719 def.name = "VueElement"; 18720 } 18721 this._app = this._createApp(def); 18722 if (def.configureApp) { 18723 def.configureApp(this._app); 18724 } 18725 this._app._ceVNode = this._createVNode(); 18726 this._app.mount(this._root); 18727 const exposed = this._instance && this._instance.exposed; 18728 if (!exposed) return; 18729 for (const key in exposed) { 18730 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(this, key)) { 18731 Object.defineProperty(this, key, { 18732 // unwrap ref to be consistent with public instance behavior 18733 get: () => (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_2__.unref)(exposed[key]) 18734 }); 18735 } else if (true) { 18736 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Exposed property "${key}" already exists on custom element.`); 18737 } 18738 } 18739 } 18740 _resolveProps(def) { 18741 const { props } = def; 18742 const declaredPropKeys = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(props) ? props : Object.keys(props || {}); 18743 for (const key of Object.keys(this)) { 18744 if (key[0] !== "_" && declaredPropKeys.includes(key)) { 18745 this._setProp(key, this[key]); 18746 } 18747 } 18748 for (const key of declaredPropKeys.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)) { 18749 Object.defineProperty(this, key, { 18750 get() { 18751 return this._getProp(key); 18752 }, 18753 set(val) { 18754 this._setProp(key, val, true, true); 18755 } 18756 }); 18757 } 18758 } 18759 _setAttr(key) { 18760 if (key.startsWith("data-v-")) return; 18761 const has = this.hasAttribute(key); 18762 let value = has ? this.getAttribute(key) : REMOVAL; 18763 const camelKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key); 18764 if (has && this._numberProps && this._numberProps[camelKey]) { 18765 value = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(value); 18766 } 18767 this._setProp(camelKey, value, false, true); 18768 } 18769 /** 18770 * @internal 18771 */ 18772 _getProp(key) { 18773 return this._props[key]; 18774 } 18775 /** 18776 * @internal 18777 */ 18778 _setProp(key, val, shouldReflect = true, shouldUpdate = false) { 18779 if (val !== this._props[key]) { 18780 if (val === REMOVAL) { 18781 delete this._props[key]; 18782 } else { 18783 this._props[key] = val; 18784 if (key === "key" && this._app) { 18785 this._app._ceVNode.key = val; 18786 } 18787 } 18788 if (shouldUpdate && this._instance) { 18789 this._update(); 18790 } 18791 if (shouldReflect) { 18792 const ob = this._ob; 18793 ob && ob.disconnect(); 18794 if (val === true) { 18795 this.setAttribute((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key), ""); 18796 } else if (typeof val === "string" || typeof val === "number") { 18797 this.setAttribute((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key), val + ""); 18798 } else if (!val) { 18799 this.removeAttribute((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key)); 18800 } 18801 ob && ob.observe(this, { attributes: true }); 18802 } 18803 } 18804 } 18805 _update() { 18806 render(this._createVNode(), this._root); 18807 } 18808 _createVNode() { 18809 const baseProps = {}; 18810 if (!this.shadowRoot) { 18811 baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this); 18812 } 18813 const vnode = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createVNode)(this._def, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(baseProps, this._props)); 18814 if (!this._instance) { 18815 vnode.ce = (instance) => { 18816 this._instance = instance; 18817 instance.ce = this; 18818 instance.isCE = true; 18819 if (true) { 18820 instance.ceReload = (newStyles) => { 18821 if (this._styles) { 18822 this._styles.forEach((s) => this._root.removeChild(s)); 18823 this._styles.length = 0; 18824 } 18825 this._applyStyles(newStyles); 18826 this._instance = null; 18827 this._update(); 18828 }; 18829 } 18830 const dispatch = (event, args) => { 18831 this.dispatchEvent( 18832 new CustomEvent( 18833 event, 18834 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPlainObject)(args[0]) ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({ detail: args }, args[0]) : { detail: args } 18835 ) 18836 ); 18837 }; 18838 instance.emit = (event, ...args) => { 18839 dispatch(event, args); 18840 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event) !== event) { 18841 dispatch((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event), args); 18842 } 18843 }; 18844 this._setParent(); 18845 }; 18846 } 18847 return vnode; 18848 } 18849 _applyStyles(styles, owner) { 18850 if (!styles) return; 18851 if (owner) { 18852 if (owner === this._def || this._styleChildren.has(owner)) { 18853 return; 18854 } 18855 this._styleChildren.add(owner); 18856 } 18857 const nonce = this._nonce; 18858 for (let i = styles.length - 1; i >= 0; i--) { 18859 const s = document.createElement("style"); 18860 if (nonce) s.setAttribute("nonce", nonce); 18861 s.textContent = styles[i]; 18862 this.shadowRoot.prepend(s); 18863 if (true) { 18864 if (owner) { 18865 if (owner.__hmrId) { 18866 if (!this._childStyles) this._childStyles = /* @__PURE__ */ new Map(); 18867 let entry = this._childStyles.get(owner.__hmrId); 18868 if (!entry) { 18869 this._childStyles.set(owner.__hmrId, entry = []); 18870 } 18871 entry.push(s); 18872 } 18873 } else { 18874 (this._styles || (this._styles = [])).push(s); 18875 } 18876 } 18877 } 18878 } 18879 /** 18880 * Only called when shadowRoot is false 18881 */ 18882 _parseSlots() { 18883 const slots = this._slots = {}; 18884 let n; 18885 while (n = this.firstChild) { 18886 const slotName = n.nodeType === 1 && n.getAttribute("slot") || "default"; 18887 (slots[slotName] || (slots[slotName] = [])).push(n); 18888 this.removeChild(n); 18889 } 18890 } 18891 /** 18892 * Only called when shadowRoot is false 18893 */ 18894 _renderSlots() { 18895 const outlets = (this._teleportTarget || this).querySelectorAll("slot"); 18896 const scopeId = this._instance.type.__scopeId; 18897 for (let i = 0; i < outlets.length; i++) { 18898 const o = outlets[i]; 18899 const slotName = o.getAttribute("name") || "default"; 18900 const content = this._slots[slotName]; 18901 const parent = o.parentNode; 18902 if (content) { 18903 for (const n of content) { 18904 if (scopeId && n.nodeType === 1) { 18905 const id = scopeId + "-s"; 18906 const walker = document.createTreeWalker(n, 1); 18907 n.setAttribute(id, ""); 18908 let child; 18909 while (child = walker.nextNode()) { 18910 child.setAttribute(id, ""); 18911 } 18912 } 18913 parent.insertBefore(n, o); 18914 } 18915 } else { 18916 while (o.firstChild) parent.insertBefore(o.firstChild, o); 18917 } 18918 parent.removeChild(o); 18919 } 18920 } 18921 /** 18922 * @internal 18923 */ 18924 _injectChildStyle(comp) { 18925 this._applyStyles(comp.styles, comp); 18926 } 18927 /** 18928 * @internal 18929 */ 18930 _removeChildStyle(comp) { 18931 if (true) { 18932 this._styleChildren.delete(comp); 18933 if (this._childStyles && comp.__hmrId) { 18934 const oldStyles = this._childStyles.get(comp.__hmrId); 18935 if (oldStyles) { 18936 oldStyles.forEach((s) => this._root.removeChild(s)); 18937 oldStyles.length = 0; 18938 } 18939 } 18940 } 18941 } 18942} 18943function useHost(caller) { 18944 const instance = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)(); 18945 const el = instance && instance.ce; 18946 if (el) { 18947 return el; 18948 } else if (true) { 18949 if (!instance) { 18950 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 18951 `${caller || "useHost"} called without an active component instance.` 18952 ); 18953 } else { 18954 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 18955 `${caller || "useHost"} can only be used in components defined via defineCustomElement.` 18956 ); 18957 } 18958 } 18959 return null; 18960} 18961function useShadowRoot() { 18962 const el = true ? useHost("useShadowRoot") : 0; 18963 return el && el.shadowRoot; 18964} 18965 18966function useCssModule(name = "$style") { 18967 { 18968 const instance = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)(); 18969 if (!instance) { 18970 true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`useCssModule must be called inside setup()`); 18971 return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 18972 } 18973 const modules = instance.type.__cssModules; 18974 if (!modules) { 18975 true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Current instance does not have CSS modules injected.`); 18976 return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 18977 } 18978 const mod = modules[name]; 18979 if (!mod) { 18980 true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Current instance does not have CSS module named "${name}".`); 18981 return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 18982 } 18983 return mod; 18984 } 18985} 18986 18987const positionMap = /* @__PURE__ */ new WeakMap(); 18988const newPositionMap = /* @__PURE__ */ new WeakMap(); 18989const moveCbKey = Symbol("_moveCb"); 18990const enterCbKey = Symbol("_enterCb"); 18991const decorate = (t) => { 18992 delete t.props.mode; 18993 return t; 18994}; 18995const TransitionGroupImpl = /* @__PURE__ */ decorate({ 18996 name: "TransitionGroup", 18997 props: /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, TransitionPropsValidators, { 18998 tag: String, 18999 moveClass: String 19000 }), 19001 setup(props, { slots }) { 19002 const instance = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)(); 19003 const state = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useTransitionState)(); 19004 let prevChildren; 19005 let children; 19006 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUpdated)(() => { 19007 if (!prevChildren.length) { 19008 return; 19009 } 19010 const moveClass = props.moveClass || `${props.name || "v"}-move`; 19011 if (!hasCSSTransform( 19012 prevChildren[0].el, 19013 instance.vnode.el, 19014 moveClass 19015 )) { 19016 return; 19017 } 19018 prevChildren.forEach(callPendingCbs); 19019 prevChildren.forEach(recordPosition); 19020 const movedChildren = prevChildren.filter(applyTranslation); 19021 forceReflow(); 19022 movedChildren.forEach((c) => { 19023 const el = c.el; 19024 const style = el.style; 19025 addTransitionClass(el, moveClass); 19026 style.transform = style.webkitTransform = style.transitionDuration = ""; 19027 const cb = el[moveCbKey] = (e) => { 19028 if (e && e.target !== el) { 19029 return; 19030 } 19031 if (!e || /transform$/.test(e.propertyName)) { 19032 el.removeEventListener("transitionend", cb); 19033 el[moveCbKey] = null; 19034 removeTransitionClass(el, moveClass); 19035 } 19036 }; 19037 el.addEventListener("transitionend", cb); 19038 }); 19039 }); 19040 return () => { 19041 const rawProps = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_2__.toRaw)(props); 19042 const cssTransitionProps = resolveTransitionProps(rawProps); 19043 let tag = rawProps.tag || _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Fragment; 19044 prevChildren = []; 19045 if (children) { 19046 for (let i = 0; i < children.length; i++) { 19047 const child = children[i]; 19048 if (child.el && child.el instanceof Element) { 19049 prevChildren.push(child); 19050 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks)( 19051 child, 19052 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks)( 19053 child, 19054 cssTransitionProps, 19055 state, 19056 instance 19057 ) 19058 ); 19059 positionMap.set( 19060 child, 19061 child.el.getBoundingClientRect() 19062 ); 19063 } 19064 } 19065 } 19066 children = slots.default ? (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren)(slots.default()) : []; 19067 for (let i = 0; i < children.length; i++) { 19068 const child = children[i]; 19069 if (child.key != null) { 19070 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks)( 19071 child, 19072 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks)(child, cssTransitionProps, state, instance) 19073 ); 19074 } else if ( true && child.type !== _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Text) { 19075 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`<TransitionGroup> children must be keyed.`); 19076 } 19077 } 19078 return (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createVNode)(tag, null, children); 19079 }; 19080 } 19081}); 19082const TransitionGroup = TransitionGroupImpl; 19083function callPendingCbs(c) { 19084 const el = c.el; 19085 if (el[moveCbKey]) { 19086 el[moveCbKey](); 19087 } 19088 if (el[enterCbKey]) { 19089 el[enterCbKey](); 19090 } 19091} 19092function recordPosition(c) { 19093 newPositionMap.set(c, c.el.getBoundingClientRect()); 19094} 19095function applyTranslation(c) { 19096 const oldPos = positionMap.get(c); 19097 const newPos = newPositionMap.get(c); 19098 const dx = oldPos.left - newPos.left; 19099 const dy = oldPos.top - newPos.top; 19100 if (dx || dy) { 19101 const s = c.el.style; 19102 s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`; 19103 s.transitionDuration = "0s"; 19104 return c; 19105 } 19106} 19107function hasCSSTransform(el, root, moveClass) { 19108 const clone = el.cloneNode(); 19109 const _vtc = el[vtcKey]; 19110 if (_vtc) { 19111 _vtc.forEach((cls) => { 19112 cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c)); 19113 }); 19114 } 19115 moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c)); 19116 clone.style.display = "none"; 19117 const container = root.nodeType === 1 ? root : root.parentNode; 19118 container.appendChild(clone); 19119 const { hasTransform } = getTransitionInfo(clone); 19120 container.removeChild(clone); 19121 return hasTransform; 19122} 19123 19124const getModelAssigner = (vnode) => { 19125 const fn = vnode.props["onUpdate:modelValue"] || false; 19126 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(fn) ? (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(fn, value) : fn; 19127}; 19128function onCompositionStart(e) { 19129 e.target.composing = true; 19130} 19131function onCompositionEnd(e) { 19132 const target = e.target; 19133 if (target.composing) { 19134 target.composing = false; 19135 target.dispatchEvent(new Event("input")); 19136 } 19137} 19138const assignKey = Symbol("_assign"); 19139const vModelText = { 19140 created(el, { modifiers: { lazy, trim, number } }, vnode) { 19141 el[assignKey] = getModelAssigner(vnode); 19142 const castToNumber = number || vnode.props && vnode.props.type === "number"; 19143 addEventListener(el, lazy ? "change" : "input", (e) => { 19144 if (e.target.composing) return; 19145 let domValue = el.value; 19146 if (trim) { 19147 domValue = domValue.trim(); 19148 } 19149 if (castToNumber) { 19150 domValue = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseToNumber)(domValue); 19151 } 19152 el[assignKey](domValue); 19153 }); 19154 if (trim) { 19155 addEventListener(el, "change", () => { 19156 el.value = el.value.trim(); 19157 }); 19158 } 19159 if (!lazy) { 19160 addEventListener(el, "compositionstart", onCompositionStart); 19161 addEventListener(el, "compositionend", onCompositionEnd); 19162 addEventListener(el, "change", onCompositionEnd); 19163 } 19164 }, 19165 // set value on mounted so it's after min/max for type="range" 19166 mounted(el, { value }) { 19167 el.value = value == null ? "" : value; 19168 }, 19169 beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) { 19170 el[assignKey] = getModelAssigner(vnode); 19171 if (el.composing) return; 19172 const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseToNumber)(el.value) : el.value; 19173 const newValue = value == null ? "" : value; 19174 if (elValue === newValue) { 19175 return; 19176 } 19177 if (document.activeElement === el && el.type !== "range") { 19178 if (lazy && value === oldValue) { 19179 return; 19180 } 19181 if (trim && el.value.trim() === newValue) { 19182 return; 19183 } 19184 } 19185 el.value = newValue; 19186 } 19187}; 19188const vModelCheckbox = { 19189 // #4096 array checkboxes need to be deep traversed 19190 deep: true, 19191 created(el, _, vnode) { 19192 el[assignKey] = getModelAssigner(vnode); 19193 addEventListener(el, "change", () => { 19194 const modelValue = el._modelValue; 19195 const elementValue = getValue(el); 19196 const checked = el.checked; 19197 const assign = el[assignKey]; 19198 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(modelValue)) { 19199 const index = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(modelValue, elementValue); 19200 const found = index !== -1; 19201 if (checked && !found) { 19202 assign(modelValue.concat(elementValue)); 19203 } else if (!checked && found) { 19204 const filtered = [...modelValue]; 19205 filtered.splice(index, 1); 19206 assign(filtered); 19207 } 19208 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(modelValue)) { 19209 const cloned = new Set(modelValue); 19210 if (checked) { 19211 cloned.add(elementValue); 19212 } else { 19213 cloned.delete(elementValue); 19214 } 19215 assign(cloned); 19216 } else { 19217 assign(getCheckboxValue(el, checked)); 19218 } 19219 }); 19220 }, 19221 // set initial checked on mount to wait for true-value/false-value 19222 mounted: setChecked, 19223 beforeUpdate(el, binding, vnode) { 19224 el[assignKey] = getModelAssigner(vnode); 19225 setChecked(el, binding, vnode); 19226 } 19227}; 19228function setChecked(el, { value, oldValue }, vnode) { 19229 el._modelValue = value; 19230 let checked; 19231 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) { 19232 checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(value, vnode.props.value) > -1; 19233 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value)) { 19234 checked = value.has(vnode.props.value); 19235 } else { 19236 if (value === oldValue) return; 19237 checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(value, getCheckboxValue(el, true)); 19238 } 19239 if (el.checked !== checked) { 19240 el.checked = checked; 19241 } 19242} 19243const vModelRadio = { 19244 created(el, { value }, vnode) { 19245 el.checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(value, vnode.props.value); 19246 el[assignKey] = getModelAssigner(vnode); 19247 addEventListener(el, "change", () => { 19248 el[assignKey](getValue(el)); 19249 }); 19250 }, 19251 beforeUpdate(el, { value, oldValue }, vnode) { 19252 el[assignKey] = getModelAssigner(vnode); 19253 if (value !== oldValue) { 19254 el.checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(value, vnode.props.value); 19255 } 19256 } 19257}; 19258const vModelSelect = { 19259 // <select multiple> value need to be deep traversed 19260 deep: true, 19261 created(el, { value, modifiers: { number } }, vnode) { 19262 const isSetModel = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value); 19263 addEventListener(el, "change", () => { 19264 const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map( 19265 (o) => number ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseToNumber)(getValue(o)) : getValue(o) 19266 ); 19267 el[assignKey]( 19268 el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0] 19269 ); 19270 el._assigning = true; 19271 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => { 19272 el._assigning = false; 19273 }); 19274 }); 19275 el[assignKey] = getModelAssigner(vnode); 19276 }, 19277 // set value in mounted & updated because <select> relies on its children 19278 // <option>s. 19279 mounted(el, { value }) { 19280 setSelected(el, value); 19281 }, 19282 beforeUpdate(el, _binding, vnode) { 19283 el[assignKey] = getModelAssigner(vnode); 19284 }, 19285 updated(el, { value }) { 19286 if (!el._assigning) { 19287 setSelected(el, value); 19288 } 19289 } 19290}; 19291function setSelected(el, value) { 19292 const isMultiple = el.multiple; 19293 const isArrayValue = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value); 19294 if (isMultiple && !isArrayValue && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value)) { 19295 true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 19296 `<select multiple v-model> expects an Array or Set value for its binding, but got ${Object.prototype.toString.call(value).slice(8, -1)}.` 19297 ); 19298 return; 19299 } 19300 for (let i = 0, l = el.options.length; i < l; i++) { 19301 const option = el.options[i]; 19302 const optionValue = getValue(option); 19303 if (isMultiple) { 19304 if (isArrayValue) { 19305 const optionType = typeof optionValue; 19306 if (optionType === "string" || optionType === "number") { 19307 option.selected = value.some((v) => String(v) === String(optionValue)); 19308 } else { 19309 option.selected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(value, optionValue) > -1; 19310 } 19311 } else { 19312 option.selected = value.has(optionValue); 19313 } 19314 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(getValue(option), value)) { 19315 if (el.selectedIndex !== i) el.selectedIndex = i; 19316 return; 19317 } 19318 } 19319 if (!isMultiple && el.selectedIndex !== -1) { 19320 el.selectedIndex = -1; 19321 } 19322} 19323function getValue(el) { 19324 return "_value" in el ? el._value : el.value; 19325} 19326function getCheckboxValue(el, checked) { 19327 const key = checked ? "_trueValue" : "_falseValue"; 19328 return key in el ? el[key] : checked; 19329} 19330const vModelDynamic = { 19331 created(el, binding, vnode) { 19332 callModelHook(el, binding, vnode, null, "created"); 19333 }, 19334 mounted(el, binding, vnode) { 19335 callModelHook(el, binding, vnode, null, "mounted"); 19336 }, 19337 beforeUpdate(el, binding, vnode, prevVNode) { 19338 callModelHook(el, binding, vnode, prevVNode, "beforeUpdate"); 19339 }, 19340 updated(el, binding, vnode, prevVNode) { 19341 callModelHook(el, binding, vnode, prevVNode, "updated"); 19342 } 19343}; 19344function resolveDynamicModel(tagName, type) { 19345 switch (tagName) { 19346 case "SELECT": 19347 return vModelSelect; 19348 case "TEXTAREA": 19349 return vModelText; 19350 default: 19351 switch (type) { 19352 case "checkbox": 19353 return vModelCheckbox; 19354 case "radio": 19355 return vModelRadio; 19356 default: 19357 return vModelText; 19358 } 19359 } 19360} 19361function callModelHook(el, binding, vnode, prevVNode, hook) { 19362 const modelToUse = resolveDynamicModel( 19363 el.tagName, 19364 vnode.props && vnode.props.type 19365 ); 19366 const fn = modelToUse[hook]; 19367 fn && fn(el, binding, vnode, prevVNode); 19368} 19369function initVModelForSSR() { 19370 vModelText.getSSRProps = ({ value }) => ({ value }); 19371 vModelRadio.getSSRProps = ({ value }, vnode) => { 19372 if (vnode.props && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(vnode.props.value, value)) { 19373 return { checked: true }; 19374 } 19375 }; 19376 vModelCheckbox.getSSRProps = ({ value }, vnode) => { 19377 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) { 19378 if (vnode.props && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(value, vnode.props.value) > -1) { 19379 return { checked: true }; 19380 } 19381 } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value)) { 19382 if (vnode.props && value.has(vnode.props.value)) { 19383 return { checked: true }; 19384 } 19385 } else if (value) { 19386 return { checked: true }; 19387 } 19388 }; 19389 vModelDynamic.getSSRProps = (binding, vnode) => { 19390 if (typeof vnode.type !== "string") { 19391 return; 19392 } 19393 const modelToUse = resolveDynamicModel( 19394 // resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase 19395 vnode.type.toUpperCase(), 19396 vnode.props && vnode.props.type 19397 ); 19398 if (modelToUse.getSSRProps) { 19399 return modelToUse.getSSRProps(binding, vnode); 19400 } 19401 }; 19402} 19403 19404const systemModifiers = ["ctrl", "shift", "alt", "meta"]; 19405const modifierGuards = { 19406 stop: (e) => e.stopPropagation(), 19407 prevent: (e) => e.preventDefault(), 19408 self: (e) => e.target !== e.currentTarget, 19409 ctrl: (e) => !e.ctrlKey, 19410 shift: (e) => !e.shiftKey, 19411 alt: (e) => !e.altKey, 19412 meta: (e) => !e.metaKey, 19413 left: (e) => "button" in e && e.button !== 0, 19414 middle: (e) => "button" in e && e.button !== 1, 19415 right: (e) => "button" in e && e.button !== 2, 19416 exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m)) 19417}; 19418const withModifiers = (fn, modifiers) => { 19419 const cache = fn._withMods || (fn._withMods = {}); 19420 const cacheKey = modifiers.join("."); 19421 return cache[cacheKey] || (cache[cacheKey] = (event, ...args) => { 19422 for (let i = 0; i < modifiers.length; i++) { 19423 const guard = modifierGuards[modifiers[i]]; 19424 if (guard && guard(event, modifiers)) return; 19425 } 19426 return fn(event, ...args); 19427 }); 19428}; 19429const keyNames = { 19430 esc: "escape", 19431 space: " ", 19432 up: "arrow-up", 19433 left: "arrow-left", 19434 right: "arrow-right", 19435 down: "arrow-down", 19436 delete: "backspace" 19437}; 19438const withKeys = (fn, modifiers) => { 19439 const cache = fn._withKeys || (fn._withKeys = {}); 19440 const cacheKey = modifiers.join("."); 19441 return cache[cacheKey] || (cache[cacheKey] = (event) => { 19442 if (!("key" in event)) { 19443 return; 19444 } 19445 const eventKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event.key); 19446 if (modifiers.some( 19447 (k) => k === eventKey || keyNames[k] === eventKey 19448 )) { 19449 return fn(event); 19450 } 19451 }); 19452}; 19453 19454const rendererOptions = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({ patchProp }, nodeOps); 19455let renderer; 19456let enabledHydration = false; 19457function ensureRenderer() { 19458 return renderer || (renderer = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createRenderer)(rendererOptions)); 19459} 19460function ensureHydrationRenderer() { 19461 renderer = enabledHydration ? renderer : (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer)(rendererOptions); 19462 enabledHydration = true; 19463 return renderer; 19464} 19465const render = (...args) => { 19466 ensureRenderer().render(...args); 19467}; 19468const hydrate = (...args) => { 19469 ensureHydrationRenderer().hydrate(...args); 19470}; 19471const createApp = (...args) => { 19472 const app = ensureRenderer().createApp(...args); 19473 if (true) { 19474 injectNativeTagCheck(app); 19475 injectCompilerOptionsCheck(app); 19476 } 19477 const { mount } = app; 19478 app.mount = (containerOrSelector) => { 19479 const container = normalizeContainer(containerOrSelector); 19480 if (!container) return; 19481 const component = app._component; 19482 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(component) && !component.render && !component.template) { 19483 component.template = container.innerHTML; 19484 } 19485 if (container.nodeType === 1) { 19486 container.textContent = ""; 19487 } 19488 const proxy = mount(container, false, resolveRootNamespace(container)); 19489 if (container instanceof Element) { 19490 container.removeAttribute("v-cloak"); 19491 container.setAttribute("data-v-app", ""); 19492 } 19493 return proxy; 19494 }; 19495 return app; 19496}; 19497const createSSRApp = (...args) => { 19498 const app = ensureHydrationRenderer().createApp(...args); 19499 if (true) { 19500 injectNativeTagCheck(app); 19501 injectCompilerOptionsCheck(app); 19502 } 19503 const { mount } = app; 19504 app.mount = (containerOrSelector) => { 19505 const container = normalizeContainer(containerOrSelector); 19506 if (container) { 19507 return mount(container, true, resolveRootNamespace(container)); 19508 } 19509 }; 19510 return app; 19511}; 19512function resolveRootNamespace(container) { 19513 if (container instanceof SVGElement) { 19514 return "svg"; 19515 } 19516 if (typeof MathMLElement === "function" && container instanceof MathMLElement) { 19517 return "mathml"; 19518 } 19519} 19520function injectNativeTagCheck(app) { 19521 Object.defineProperty(app.config, "isNativeTag", { 19522 value: (tag) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isHTMLTag)(tag) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSVGTag)(tag) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isMathMLTag)(tag), 19523 writable: false 19524 }); 19525} 19526function injectCompilerOptionsCheck(app) { 19527 if ((0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly)()) { 19528 const isCustomElement = app.config.isCustomElement; 19529 Object.defineProperty(app.config, "isCustomElement", { 19530 get() { 19531 return isCustomElement; 19532 }, 19533 set() { 19534 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 19535 `The \`isCustomElement\` config option is deprecated. Use \`compilerOptions.isCustomElement\` instead.` 19536 ); 19537 } 19538 }); 19539 const compilerOptions = app.config.compilerOptions; 19540 const msg = `The \`compilerOptions\` config option is only respected when using a build of Vue.js that includes the runtime compiler (aka "full build"). Since you are using the runtime-only build, \`compilerOptions\` must be passed to \`@vue/compiler-dom\` in the build setup instead. 19541- For vue-loader: pass it via vue-loader's \`compilerOptions\` loader option. 19542- For vue-cli: see https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader 19543- For vite: pass it via @vitejs/plugin-vue options. See https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-sfc`; 19544 Object.defineProperty(app.config, "compilerOptions", { 19545 get() { 19546 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(msg); 19547 return compilerOptions; 19548 }, 19549 set() { 19550 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(msg); 19551 } 19552 }); 19553 } 19554} 19555function normalizeContainer(container) { 19556 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(container)) { 19557 const res = document.querySelector(container); 19558 if ( true && !res) { 19559 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 19560 `Failed to mount app: mount target selector "${container}" returned null.` 19561 ); 19562 } 19563 return res; 19564 } 19565 if ( true && window.ShadowRoot && container instanceof window.ShadowRoot && container.mode === "closed") { 19566 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)( 19567 `mounting on a ShadowRoot with \`{mode: "closed"}\` may lead to unpredictable bugs` 19568 ); 19569 } 19570 return container; 19571} 19572let ssrDirectiveInitialized = false; 19573const initDirectivesForSSR = () => { 19574 if (!ssrDirectiveInitialized) { 19575 ssrDirectiveInitialized = true; 19576 initVModelForSSR(); 19577 initVShowForSSR(); 19578 } 19579} ; 19580 19581 19582 19583 19584/***/ }), 19585
vendor: 27,231 bytes, lines 19586-20190
19586/***/ "./node_modules/@vue/shared/dist/shared.esm-bundler.js": 19587/*!*************************************************************!*\ 19588 !*** ./node_modules/@vue/shared/dist/shared.esm-bundler.js ***! 19589 \*************************************************************/ 19590/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 19591 19592"use strict"; 19593__webpack_require__.r(__webpack_exports__); 19594/* harmony export */ __webpack_require__.d(__webpack_exports__, { 19595/* harmony export */ EMPTY_ARR: () => (/* binding */ EMPTY_ARR), 19596/* harmony export */ EMPTY_OBJ: () => (/* binding */ EMPTY_OBJ), 19597/* harmony export */ NO: () => (/* binding */ NO), 19598/* harmony export */ NOOP: () => (/* binding */ NOOP), 19599/* harmony export */ PatchFlagNames: () => (/* binding */ PatchFlagNames), 19600/* harmony export */ PatchFlags: () => (/* binding */ PatchFlags), 19601/* harmony export */ ShapeFlags: () => (/* binding */ ShapeFlags), 19602/* harmony export */ SlotFlags: () => (/* binding */ SlotFlags), 19603/* harmony export */ camelize: () => (/* binding */ camelize), 19604/* harmony export */ capitalize: () => (/* binding */ capitalize), 19605/* harmony export */ cssVarNameEscapeSymbolsRE: () => (/* binding */ cssVarNameEscapeSymbolsRE), 19606/* harmony export */ def: () => (/* binding */ def), 19607/* harmony export */ escapeHtml: () => (/* binding */ escapeHtml), 19608/* harmony export */ escapeHtmlComment: () => (/* binding */ escapeHtmlComment), 19609/* harmony export */ extend: () => (/* binding */ extend), 19610/* harmony export */ genCacheKey: () => (/* binding */ genCacheKey), 19611/* harmony export */ genPropsAccessExp: () => (/* binding */ genPropsAccessExp), 19612/* harmony export */ generateCodeFrame: () => (/* binding */ generateCodeFrame), 19613/* harmony export */ getEscapedCssVarName: () => (/* binding */ getEscapedCssVarName), 19614/* harmony export */ getGlobalThis: () => (/* binding */ getGlobalThis), 19615/* harmony export */ hasChanged: () => (/* binding */ hasChanged), 19616/* harmony export */ hasOwn: () => (/* binding */ hasOwn), 19617/* harmony export */ hyphenate: () => (/* binding */ hyphenate), 19618/* harmony export */ includeBooleanAttr: () => (/* binding */ includeBooleanAttr), 19619/* harmony export */ invokeArrayFns: () => (/* binding */ invokeArrayFns), 19620/* harmony export */ isArray: () => (/* binding */ isArray), 19621/* harmony export */ isBooleanAttr: () => (/* binding */ isBooleanAttr), 19622/* harmony export */ isBuiltInDirective: () => (/* binding */ isBuiltInDirective), 19623/* harmony export */ isDate: () => (/* binding */ isDate), 19624/* harmony export */ isFunction: () => (/* binding */ isFunction), 19625/* harmony export */ isGloballyAllowed: () => (/* binding */ isGloballyAllowed), 19626/* harmony export */ isGloballyWhitelisted: () => (/* binding */ isGloballyWhitelisted), 19627/* harmony export */ isHTMLTag: () => (/* binding */ isHTMLTag), 19628/* harmony export */ isIntegerKey: () => (/* binding */ isIntegerKey), 19629/* harmony export */ isKnownHtmlAttr: () => (/* binding */ isKnownHtmlAttr), 19630/* harmony export */ isKnownMathMLAttr: () => (/* binding */ isKnownMathMLAttr), 19631/* harmony export */ isKnownSvgAttr: () => (/* binding */ isKnownSvgAttr), 19632/* harmony export */ isMap: () => (/* binding */ isMap), 19633/* harmony export */ isMathMLTag: () => (/* binding */ isMathMLTag), 19634/* harmony export */ isModelListener: () => (/* binding */ isModelListener), 19635/* harmony export */ isObject: () => (/* binding */ isObject), 19636/* harmony export */ isOn: () => (/* binding */ isOn), 19637/* harmony export */ isPlainObject: () => (/* binding */ isPlainObject), 19638/* harmony export */ isPromise: () => (/* binding */ isPromise), 19639/* harmony export */ isRegExp: () => (/* binding */ isRegExp), 19640/* harmony export */ isRenderableAttrValue: () => (/* binding */ isRenderableAttrValue), 19641/* harmony export */ isReservedProp: () => (/* binding */ isReservedProp), 19642/* harmony export */ isSSRSafeAttrName: () => (/* binding */ isSSRSafeAttrName), 19643/* harmony export */ isSVGTag: () => (/* binding */ isSVGTag), 19644/* harmony export */ isSet: () => (/* binding */ isSet), 19645/* harmony export */ isSpecialBooleanAttr: () => (/* binding */ isSpecialBooleanAttr), 19646/* harmony export */ isString: () => (/* binding */ isString), 19647/* harmony export */ isSymbol: () => (/* binding */ isSymbol), 19648/* harmony export */ isVoidTag: () => (/* binding */ isVoidTag), 19649/* harmony export */ looseEqual: () => (/* binding */ looseEqual), 19650/* harmony export */ looseIndexOf: () => (/* binding */ looseIndexOf), 19651/* harmony export */ looseToNumber: () => (/* binding */ looseToNumber), 19652/* harmony export */ makeMap: () => (/* binding */ makeMap), 19653/* harmony export */ normalizeClass: () => (/* binding */ normalizeClass), 19654/* harmony export */ normalizeProps: () => (/* binding */ normalizeProps), 19655/* harmony export */ normalizeStyle: () => (/* binding */ normalizeStyle), 19656/* harmony export */ objectToString: () => (/* binding */ objectToString), 19657/* harmony export */ parseStringStyle: () => (/* binding */ parseStringStyle), 19658/* harmony export */ propsToAttrMap: () => (/* binding */ propsToAttrMap), 19659/* harmony export */ remove: () => (/* binding */ remove), 19660/* harmony export */ slotFlagsText: () => (/* binding */ slotFlagsText), 19661/* harmony export */ stringifyStyle: () => (/* binding */ stringifyStyle), 19662/* harmony export */ toDisplayString: () => (/* binding */ toDisplayString), 19663/* harmony export */ toHandlerKey: () => (/* binding */ toHandlerKey), 19664/* harmony export */ toNumber: () => (/* binding */ toNumber), 19665/* harmony export */ toRawType: () => (/* binding */ toRawType), 19666/* harmony export */ toTypeString: () => (/* binding */ toTypeString) 19667/* harmony export */ }); 19668/** 19669* @vue/shared v3.5.13 19670* (c) 2018-present Yuxi (Evan) You and Vue contributors 19671* @license MIT 19672**/ 19673/*! #__NO_SIDE_EFFECTS__ */ 19674// @__NO_SIDE_EFFECTS__ 19675function makeMap(str) { 19676 const map = /* @__PURE__ */ Object.create(null); 19677 for (const key of str.split(",")) map[key] = 1; 19678 return (val) => val in map; 19679} 19680 19681const EMPTY_OBJ = true ? Object.freeze({}) : 0; 19682const EMPTY_ARR = true ? Object.freeze([]) : 0; 19683const NOOP = () => { 19684}; 19685const NO = () => false; 19686const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter 19687(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97); 19688const isModelListener = (key) => key.startsWith("onUpdate:"); 19689const extend = Object.assign; 19690const remove = (arr, el) => { 19691 const i = arr.indexOf(el); 19692 if (i > -1) { 19693 arr.splice(i, 1); 19694 } 19695}; 19696const hasOwnProperty = Object.prototype.hasOwnProperty; 19697const hasOwn = (val, key) => hasOwnProperty.call(val, key); 19698const isArray = Array.isArray; 19699const isMap = (val) => toTypeString(val) === "[object Map]"; 19700const isSet = (val) => toTypeString(val) === "[object Set]"; 19701const isDate = (val) => toTypeString(val) === "[object Date]"; 19702const isRegExp = (val) => toTypeString(val) === "[object RegExp]"; 19703const isFunction = (val) => typeof val === "function"; 19704const isString = (val) => typeof val === "string"; 19705const isSymbol = (val) => typeof val === "symbol"; 19706const isObject = (val) => val !== null && typeof val === "object"; 19707const isPromise = (val) => { 19708 return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch); 19709}; 19710const objectToString = Object.prototype.toString; 19711const toTypeString = (value) => objectToString.call(value); 19712const toRawType = (value) => { 19713 return toTypeString(value).slice(8, -1); 19714}; 19715const isPlainObject = (val) => toTypeString(val) === "[object Object]"; 19716const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key; 19717const isReservedProp = /* @__PURE__ */ makeMap( 19718 // the leading comma is intentional so empty string "" is also included 19719 ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted" 19720); 19721const isBuiltInDirective = /* @__PURE__ */ makeMap( 19722 "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo" 19723); 19724const cacheStringFunction = (fn) => { 19725 const cache = /* @__PURE__ */ Object.create(null); 19726 return (str) => { 19727 const hit = cache[str]; 19728 return hit || (cache[str] = fn(str)); 19729 }; 19730}; 19731const camelizeRE = /-(\w)/g; 19732const camelize = cacheStringFunction( 19733 (str) => { 19734 return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : ""); 19735 } 19736); 19737const hyphenateRE = /\B([A-Z])/g; 19738const hyphenate = cacheStringFunction( 19739 (str) => str.replace(hyphenateRE, "-$1").toLowerCase() 19740); 19741const capitalize = cacheStringFunction((str) => { 19742 return str.charAt(0).toUpperCase() + str.slice(1); 19743}); 19744const toHandlerKey = cacheStringFunction( 19745 (str) => { 19746 const s = str ? `on${capitalize(str)}` : ``; 19747 return s; 19748 } 19749); 19750const hasChanged = (value, oldValue) => !Object.is(value, oldValue); 19751const invokeArrayFns = (fns, ...arg) => { 19752 for (let i = 0; i < fns.length; i++) { 19753 fns[i](...arg); 19754 } 19755}; 19756const def = (obj, key, value, writable = false) => { 19757 Object.defineProperty(obj, key, { 19758 configurable: true, 19759 enumerable: false, 19760 writable, 19761 value 19762 }); 19763}; 19764const looseToNumber = (val) => { 19765 const n = parseFloat(val); 19766 return isNaN(n) ? val : n; 19767}; 19768const toNumber = (val) => { 19769 const n = isString(val) ? Number(val) : NaN; 19770 return isNaN(n) ? val : n; 19771}; 19772let _globalThis; 19773const getGlobalThis = () => { 19774 return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : {}); 19775}; 19776const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/; 19777function genPropsAccessExp(name) { 19778 return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`; 19779} 19780function genCacheKey(source, options) { 19781 return source + JSON.stringify( 19782 options, 19783 (_, val) => typeof val === "function" ? val.toString() : val 19784 ); 19785} 19786 19787const PatchFlags = { 19788 "TEXT": 1, 19789 "1": "TEXT", 19790 "CLASS": 2, 19791 "2": "CLASS", 19792 "STYLE": 4, 19793 "4": "STYLE", 19794 "PROPS": 8, 19795 "8": "PROPS", 19796 "FULL_PROPS": 16, 19797 "16": "FULL_PROPS", 19798 "NEED_HYDRATION": 32, 19799 "32": "NEED_HYDRATION", 19800 "STABLE_FRAGMENT": 64, 19801 "64": "STABLE_FRAGMENT", 19802 "KEYED_FRAGMENT": 128, 19803 "128": "KEYED_FRAGMENT", 19804 "UNKEYED_FRAGMENT": 256, 19805 "256": "UNKEYED_FRAGMENT", 19806 "NEED_PATCH": 512, 19807 "512": "NEED_PATCH", 19808 "DYNAMIC_SLOTS": 1024, 19809 "1024": "DYNAMIC_SLOTS", 19810 "DEV_ROOT_FRAGMENT": 2048, 19811 "2048": "DEV_ROOT_FRAGMENT", 19812 "CACHED": -1, 19813 "-1": "CACHED", 19814 "BAIL": -2, 19815 "-2": "BAIL" 19816}; 19817const PatchFlagNames = { 19818 [1]: `TEXT`, 19819 [2]: `CLASS`, 19820 [4]: `STYLE`, 19821 [8]: `PROPS`, 19822 [16]: `FULL_PROPS`, 19823 [32]: `NEED_HYDRATION`, 19824 [64]: `STABLE_FRAGMENT`, 19825 [128]: `KEYED_FRAGMENT`, 19826 [256]: `UNKEYED_FRAGMENT`, 19827 [512]: `NEED_PATCH`, 19828 [1024]: `DYNAMIC_SLOTS`, 19829 [2048]: `DEV_ROOT_FRAGMENT`, 19830 [-1]: `HOISTED`, 19831 [-2]: `BAIL` 19832}; 19833 19834const ShapeFlags = { 19835 "ELEMENT": 1, 19836 "1": "ELEMENT", 19837 "FUNCTIONAL_COMPONENT": 2, 19838 "2": "FUNCTIONAL_COMPONENT", 19839 "STATEFUL_COMPONENT": 4, 19840 "4": "STATEFUL_COMPONENT", 19841 "TEXT_CHILDREN": 8, 19842 "8": "TEXT_CHILDREN", 19843 "ARRAY_CHILDREN": 16, 19844 "16": "ARRAY_CHILDREN", 19845 "SLOTS_CHILDREN": 32, 19846 "32": "SLOTS_CHILDREN", 19847 "TELEPORT": 64, 19848 "64": "TELEPORT", 19849 "SUSPENSE": 128, 19850 "128": "SUSPENSE", 19851 "COMPONENT_SHOULD_KEEP_ALIVE": 256, 19852 "256": "COMPONENT_SHOULD_KEEP_ALIVE", 19853 "COMPONENT_KEPT_ALIVE": 512, 19854 "512": "COMPONENT_KEPT_ALIVE", 19855 "COMPONENT": 6, 19856 "6": "COMPONENT" 19857}; 19858 19859const SlotFlags = { 19860 "STABLE": 1, 19861 "1": "STABLE", 19862 "DYNAMIC": 2, 19863 "2": "DYNAMIC", 19864 "FORWARDED": 3, 19865 "3": "FORWARDED" 19866}; 19867const slotFlagsText = { 19868 [1]: "STABLE", 19869 [2]: "DYNAMIC", 19870 [3]: "FORWARDED" 19871}; 19872 19873const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol"; 19874const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED); 19875const isGloballyWhitelisted = isGloballyAllowed; 19876 19877const range = 2; 19878function generateCodeFrame(source, start = 0, end = source.length) { 19879 start = Math.max(0, Math.min(start, source.length)); 19880 end = Math.max(0, Math.min(end, source.length)); 19881 if (start > end) return ""; 19882 let lines = source.split(/(\r?\n)/); 19883 const newlineSequences = lines.filter((_, idx) => idx % 2 === 1); 19884 lines = lines.filter((_, idx) => idx % 2 === 0); 19885 let count = 0; 19886 const res = []; 19887 for (let i = 0; i < lines.length; i++) { 19888 count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0); 19889 if (count >= start) { 19890 for (let j = i - range; j <= i + range || end > count; j++) { 19891 if (j < 0 || j >= lines.length) continue; 19892 const line = j + 1; 19893 res.push( 19894 `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}` 19895 ); 19896 const lineLength = lines[j].length; 19897 const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0; 19898 if (j === i) { 19899 const pad = start - (count - (lineLength + newLineSeqLength)); 19900 const length = Math.max( 19901 1, 19902 end > count ? lineLength - pad : end - start 19903 ); 19904 res.push(` | ` + " ".repeat(pad) + "^".repeat(length)); 19905 } else if (j > i) { 19906 if (end > count) { 19907 const length = Math.max(Math.min(end - count, lineLength), 1); 19908 res.push(` | ` + "^".repeat(length)); 19909 } 19910 count += lineLength + newLineSeqLength; 19911 } 19912 } 19913 break; 19914 } 19915 } 19916 return res.join("\n"); 19917} 19918 19919function normalizeStyle(value) { 19920 if (isArray(value)) { 19921 const res = {}; 19922 for (let i = 0; i < value.length; i++) { 19923 const item = value[i]; 19924 const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item); 19925 if (normalized) { 19926 for (const key in normalized) { 19927 res[key] = normalized[key]; 19928 } 19929 } 19930 } 19931 return res; 19932 } else if (isString(value) || isObject(value)) { 19933 return value; 19934 } 19935} 19936const listDelimiterRE = /;(?![^(]*\))/g; 19937const propertyDelimiterRE = /:([^]+)/; 19938const styleCommentRE = /\/\*[^]*?\*\//g; 19939function parseStringStyle(cssText) { 19940 const ret = {}; 19941 cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => { 19942 if (item) { 19943 const tmp = item.split(propertyDelimiterRE); 19944 tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); 19945 } 19946 }); 19947 return ret; 19948} 19949function stringifyStyle(styles) { 19950 if (!styles) return ""; 19951 if (isString(styles)) return styles; 19952 let ret = ""; 19953 for (const key in styles) { 19954 const value = styles[key]; 19955 if (isString(value) || typeof value === "number") { 19956 const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key); 19957 ret += `${normalizedKey}:${value};`; 19958 } 19959 } 19960 return ret; 19961} 19962function normalizeClass(value) { 19963 let res = ""; 19964 if (isString(value)) { 19965 res = value; 19966 } else if (isArray(value)) { 19967 for (let i = 0; i < value.length; i++) { 19968 const normalized = normalizeClass(value[i]); 19969 if (normalized) { 19970 res += normalized + " "; 19971 } 19972 } 19973 } else if (isObject(value)) { 19974 for (const name in value) { 19975 if (value[name]) { 19976 res += name + " "; 19977 } 19978 } 19979 } 19980 return res.trim(); 19981} 19982function normalizeProps(props) { 19983 if (!props) return null; 19984 let { class: klass, style } = props; 19985 if (klass && !isString(klass)) { 19986 props.class = normalizeClass(klass); 19987 } 19988 if (style) { 19989 props.style = normalizeStyle(style); 19990 } 19991 return props; 19992} 19993 19994const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot"; 19995const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view"; 19996const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics"; 19997const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr"; 19998const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS); 19999const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS); 20000const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS); 20001const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS); 20002 20003const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`; 20004const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs); 20005const isBooleanAttr = /* @__PURE__ */ makeMap( 20006 specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected` 20007); 20008function includeBooleanAttr(value) { 20009 return !!value || value === ""; 20010} 20011const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; 20012const attrValidationCache = {}; 20013function isSSRSafeAttrName(name) { 20014 if (attrValidationCache.hasOwnProperty(name)) { 20015 return attrValidationCache[name]; 20016 } 20017 const isUnsafe = unsafeAttrCharRE.test(name); 20018 if (isUnsafe) { 20019 console.error(`unsafe attribute name: ${name}`); 20020 } 20021 return attrValidationCache[name] = !isUnsafe; 20022} 20023const propsToAttrMap = { 20024 acceptCharset: "accept-charset", 20025 className: "class", 20026 htmlFor: "for", 20027 httpEquiv: "http-equiv" 20028}; 20029const isKnownHtmlAttr = /* @__PURE__ */ makeMap( 20030 `accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap` 20031); 20032const isKnownSvgAttr = /* @__PURE__ */ makeMap( 20033 `xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan` 20034); 20035const isKnownMathMLAttr = /* @__PURE__ */ makeMap( 20036 `accent,accentunder,actiontype,align,alignmentscope,altimg,altimg-height,altimg-valign,altimg-width,alttext,bevelled,close,columnsalign,columnlines,columnspan,denomalign,depth,dir,display,displaystyle,encoding,equalcolumns,equalrows,fence,fontstyle,fontweight,form,frame,framespacing,groupalign,height,href,id,indentalign,indentalignfirst,indentalignlast,indentshift,indentshiftfirst,indentshiftlast,indextype,justify,largetop,largeop,lquote,lspace,mathbackground,mathcolor,mathsize,mathvariant,maxsize,minlabelspacing,mode,other,overflow,position,rowalign,rowlines,rowspan,rquote,rspace,scriptlevel,scriptminsize,scriptsizemultiplier,selection,separator,separators,shift,side,src,stackalign,stretchy,subscriptshift,superscriptshift,symmetric,voffset,width,widths,xlink:href,xlink:show,xlink:type,xmlns` 20037); 20038function isRenderableAttrValue(value) { 20039 if (value == null) { 20040 return false; 20041 } 20042 const type = typeof value; 20043 return type === "string" || type === "number" || type === "boolean"; 20044} 20045 20046const escapeRE = /["'&<>]/; 20047function escapeHtml(string) { 20048 const str = "" + string; 20049 const match = escapeRE.exec(str); 20050 if (!match) { 20051 return str; 20052 } 20053 let html = ""; 20054 let escaped; 20055 let index; 20056 let lastIndex = 0; 20057 for (index = match.index; index < str.length; index++) { 20058 switch (str.charCodeAt(index)) { 20059 case 34: 20060 escaped = """; 20061 break; 20062 case 38: 20063 escaped = "&"; 20064 break; 20065 case 39: 20066 escaped = "'"; 20067 break; 20068 case 60: 20069 escaped = "<"; 20070 break; 20071 case 62: 20072 escaped = ">"; 20073 break; 20074 default: 20075 continue; 20076 } 20077 if (lastIndex !== index) { 20078 html += str.slice(lastIndex, index); 20079 } 20080 lastIndex = index + 1; 20081 html += escaped; 20082 } 20083 return lastIndex !== index ? html + str.slice(lastIndex, index) : html; 20084} 20085const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g; 20086function escapeHtmlComment(src) { 20087 return src.replace(commentStripRE, ""); 20088} 20089const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g; 20090function getEscapedCssVarName(key, doubleEscape) { 20091 return key.replace( 20092 cssVarNameEscapeSymbolsRE, 20093 (s) => doubleEscape ? s === '"' ? '\\\\\\"' : `\\\\${s}` : `\\${s}` 20094 ); 20095} 20096 20097function looseCompareArrays(a, b) { 20098 if (a.length !== b.length) return false; 20099 let equal = true; 20100 for (let i = 0; equal && i < a.length; i++) { 20101 equal = looseEqual(a[i], b[i]); 20102 } 20103 return equal; 20104} 20105function looseEqual(a, b) { 20106 if (a === b) return true; 20107 let aValidType = isDate(a); 20108 let bValidType = isDate(b); 20109 if (aValidType || bValidType) { 20110 return aValidType && bValidType ? a.getTime() === b.getTime() : false; 20111 } 20112 aValidType = isSymbol(a); 20113 bValidType = isSymbol(b); 20114 if (aValidType || bValidType) { 20115 return a === b; 20116 } 20117 aValidType = isArray(a); 20118 bValidType = isArray(b); 20119 if (aValidType || bValidType) { 20120 return aValidType && bValidType ? looseCompareArrays(a, b) : false; 20121 } 20122 aValidType = isObject(a); 20123 bValidType = isObject(b); 20124 if (aValidType || bValidType) { 20125 if (!aValidType || !bValidType) { 20126 return false; 20127 } 20128 const aKeysCount = Object.keys(a).length; 20129 const bKeysCount = Object.keys(b).length; 20130 if (aKeysCount !== bKeysCount) { 20131 return false; 20132 } 20133 for (const key in a) { 20134 const aHasKey = a.hasOwnProperty(key); 20135 const bHasKey = b.hasOwnProperty(key); 20136 if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) { 20137 return false; 20138 } 20139 } 20140 } 20141 return String(a) === String(b); 20142} 20143function looseIndexOf(arr, val) { 20144 return arr.findIndex((item) => looseEqual(item, val)); 20145} 20146 20147const isRef = (val) => { 20148 return !!(val && val["__v_isRef"] === true); 20149}; 20150const toDisplayString = (val) => { 20151 return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val); 20152}; 20153const replacer = (_key, val) => { 20154 if (isRef(val)) { 20155 return replacer(_key, val.value); 20156 } else if (isMap(val)) { 20157 return { 20158 [`Map(${val.size})`]: [...val.entries()].reduce( 20159 (entries, [key, val2], i) => { 20160 entries[stringifySymbol(key, i) + " =>"] = val2; 20161 return entries; 20162 }, 20163 {} 20164 ) 20165 }; 20166 } else if (isSet(val)) { 20167 return { 20168 [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v)) 20169 }; 20170 } else if (isSymbol(val)) { 20171 return stringifySymbol(val); 20172 } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) { 20173 return String(val); 20174 } 20175 return val; 20176}; 20177const stringifySymbol = (v, i = "") => { 20178 var _a; 20179 return ( 20180 // Symbol.description in es2019+ so we need to cast here to pass 20181 // the lib: es2016 check 20182 isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v 20183 ); 20184}; 20185 20186 20187 20188 20189/***/ }), 20190
vendor: 4,178 bytes, lines 20191-20351
20191/***/ "./node_modules/base64-js/index.js": 20192/*!*****************************************!*\ 20193 !*** ./node_modules/base64-js/index.js ***! 20194 \*****************************************/ 20195/***/ ((__unused_webpack_module, exports) => { 20196 20197"use strict"; 20198 20199 20200exports.byteLength = byteLength 20201exports.toByteArray = toByteArray 20202exports.fromByteArray = fromByteArray 20203 20204var lookup = [] 20205var revLookup = [] 20206var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array 20207 20208var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' 20209for (var i = 0, len = code.length; i < len; ++i) { 20210 lookup[i] = code[i] 20211 revLookup[code.charCodeAt(i)] = i 20212} 20213 20214// Support decoding URL-safe base64 strings, as Node.js does. 20215// See: https://en.wikipedia.org/wiki/Base64#URL_applications 20216revLookup['-'.charCodeAt(0)] = 62 20217revLookup['_'.charCodeAt(0)] = 63 20218 20219function getLens (b64) { 20220 var len = b64.length 20221 20222 if (len % 4 > 0) { 20223 throw new Error('Invalid string. Length must be a multiple of 4') 20224 } 20225 20226 // Trim off extra bytes after placeholder bytes are found 20227 // See: https://github.com/beatgammit/base64-js/issues/42 20228 var validLen = b64.indexOf('=') 20229 if (validLen === -1) validLen = len 20230 20231 var placeHoldersLen = validLen === len 20232 ? 0 20233 : 4 - (validLen % 4) 20234 20235 return [validLen, placeHoldersLen] 20236} 20237 20238// base64 is 4/3 + up to two characters of the original data 20239function byteLength (b64) { 20240 var lens = getLens(b64) 20241 var validLen = lens[0] 20242 var placeHoldersLen = lens[1] 20243 return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen 20244} 20245 20246function _byteLength (b64, validLen, placeHoldersLen) { 20247 return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen 20248} 20249 20250function toByteArray (b64) { 20251 var tmp 20252 var lens = getLens(b64) 20253 var validLen = lens[0] 20254 var placeHoldersLen = lens[1] 20255 20256 var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)) 20257 20258 var curByte = 0 20259 20260 // if there are placeholders, only get up to the last complete 4 chars 20261 var len = placeHoldersLen > 0 20262 ? validLen - 4 20263 : validLen 20264 20265 var i 20266 for (i = 0; i < len; i += 4) { 20267 tmp = 20268 (revLookup[b64.charCodeAt(i)] << 18) | 20269 (revLookup[b64.charCodeAt(i + 1)] << 12) | 20270 (revLookup[b64.charCodeAt(i + 2)] << 6) | 20271 revLookup[b64.charCodeAt(i + 3)] 20272 arr[curByte++] = (tmp >> 16) & 0xFF 20273 arr[curByte++] = (tmp >> 8) & 0xFF 20274 arr[curByte++] = tmp & 0xFF 20275 } 20276 20277 if (placeHoldersLen === 2) { 20278 tmp = 20279 (revLookup[b64.charCodeAt(i)] << 2) | 20280 (revLookup[b64.charCodeAt(i + 1)] >> 4) 20281 arr[curByte++] = tmp & 0xFF 20282 } 20283 20284 if (placeHoldersLen === 1) { 20285 tmp = 20286 (revLookup[b64.charCodeAt(i)] << 10) | 20287 (revLookup[b64.charCodeAt(i + 1)] << 4) | 20288 (revLookup[b64.charCodeAt(i + 2)] >> 2) 20289 arr[curByte++] = (tmp >> 8) & 0xFF 20290 arr[curByte++] = tmp & 0xFF 20291 } 20292 20293 return arr 20294} 20295 20296function tripletToBase64 (num) { 20297 return lookup[num >> 18 & 0x3F] + 20298 lookup[num >> 12 & 0x3F] + 20299 lookup[num >> 6 & 0x3F] + 20300 lookup[num & 0x3F] 20301} 20302 20303function encodeChunk (uint8, start, end) { 20304 var tmp 20305 var output = [] 20306 for (var i = start; i < end; i += 3) { 20307 tmp = 20308 ((uint8[i] << 16) & 0xFF0000) + 20309 ((uint8[i + 1] << 8) & 0xFF00) + 20310 (uint8[i + 2] & 0xFF) 20311 output.push(tripletToBase64(tmp)) 20312 } 20313 return output.join('') 20314} 20315 20316function fromByteArray (uint8) { 20317 var tmp 20318 var len = uint8.length 20319 var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes 20320 var parts = [] 20321 var maxChunkLength = 16383 // must be multiple of 3 20322 20323 // go through the array every three bytes, we'll deal with trailing stuff later 20324 for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { 20325 parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))) 20326 } 20327 20328 // pad the end with zeros, but make sure to not forget the extra bytes 20329 if (extraBytes === 1) { 20330 tmp = uint8[len - 1] 20331 parts.push( 20332 lookup[tmp >> 2] + 20333 lookup[(tmp << 4) & 0x3F] + 20334 '==' 20335 ) 20336 } else if (extraBytes === 2) { 20337 tmp = (uint8[len - 2] << 8) + uint8[len - 1] 20338 parts.push( 20339 lookup[tmp >> 10] + 20340 lookup[(tmp >> 4) & 0x3F] + 20341 lookup[(tmp << 2) & 0x3F] + 20342 '=' 20343 ) 20344 } 20345 20346 return parts.join('') 20347} 20348 20349 20350/***/ }), 20351
vendor: 26,475 bytes, lines 20352-20361
20352/***/ "./node_modules/bowser/es5.js": 20353/*!************************************!*\ 20354 !*** ./node_modules/bowser/es5.js ***! 20355 \************************************/ 20356/***/ (function(module) { 20357 20358!function(e,t){ true?module.exports=t():0}(this,(function(){return function(e){var t={};function r(i){if(t[i])return t[i].exports;var n=t[i]={i:i,l:!1,exports:{}};return e[i].call(n.exports,n,n.exports,r),n.l=!0,n.exports}return r.m=e,r.c=t,r.d=function(e,t,i){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:i})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var i=Object.create(null);if(r.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var n in e)r.d(i,n,function(t){return e[t]}.bind(null,n));return i},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=90)}({17:function(e,t,r){"use strict";t.__esModule=!0,t.default=void 0;var i=r(18),n=function(){function e(){}return e.getFirstMatch=function(e,t){var r=t.match(e);return r&&r.length>0&&r[1]||""},e.getSecondMatch=function(e,t){var r=t.match(e);return r&&r.length>1&&r[2]||""},e.matchAndReturnConst=function(e,t,r){if(e.test(t))return r},e.getWindowsVersionName=function(e){switch(e){case"NT":return"NT";case"XP":return"XP";case"NT 5.0":return"2000";case"NT 5.1":return"XP";case"NT 5.2":return"2003";case"NT 6.0":return"Vista";case"NT 6.1":return"7";case"NT 6.2":return"8";case"NT 6.3":return"8.1";case"NT 10.0":return"10";default:return}},e.getMacOSVersionName=function(e){var t=e.split(".").splice(0,2).map((function(e){return parseInt(e,10)||0}));if(t.push(0),10===t[0])switch(t[1]){case 5:return"Leopard";case 6:return"Snow Leopard";case 7:return"Lion";case 8:return"Mountain Lion";case 9:return"Mavericks";case 10:return"Yosemite";case 11:return"El Capitan";case 12:return"Sierra";case 13:return"High Sierra";case 14:return"Mojave";case 15:return"Catalina";default:return}},e.getAndroidVersionName=function(e){var t=e.split(".").splice(0,2).map((function(e){return parseInt(e,10)||0}));if(t.push(0),!(1===t[0]&&t[1]<5))return 1===t[0]&&t[1]<6?"Cupcake":1===t[0]&&t[1]>=6?"Donut":2===t[0]&&t[1]<2?"Eclair":2===t[0]&&2===t[1]?"Froyo":2===t[0]&&t[1]>2?"Gingerbread":3===t[0]?"Honeycomb":4===t[0]&&t[1]<1?"Ice Cream Sandwich":4===t[0]&&t[1]<4?"Jelly Bean":4===t[0]&&t[1]>=4?"KitKat":5===t[0]?"Lollipop":6===t[0]?"Marshmallow":7===t[0]?"Nougat":8===t[0]?"Oreo":9===t[0]?"Pie":void 0},e.getVersionPrecision=function(e){return e.split(".").length},e.compareVersions=function(t,r,i){void 0===i&&(i=!1);var n=e.getVersionPrecision(t),s=e.getVersionPrecision(r),a=Math.max(n,s),o=0,u=e.map([t,r],(function(t){var r=a-e.getVersionPrecision(t),i=t+new Array(r+1).join(".0");return e.map(i.split("."),(function(e){return new Array(20-e.length).join("0")+e})).reverse()}));for(i&&(o=a-Math.min(n,s)),a-=1;a>=o;){if(u[0][a]>u[1][a])return 1;if(u[0][a]===u[1][a]){if(a===o)return 0;a-=1}else if(u[0][a]<u[1][a])return-1}},e.map=function(e,t){var r,i=[];if(Array.prototype.map)return Array.prototype.map.call(e,t);for(r=0;r<e.length;r+=1)i.push(t(e[r]));return i},e.find=function(e,t){var r,i;if(Array.prototype.find)return Array.prototype.find.call(e,t);for(r=0,i=e.length;r<i;r+=1){var n=e[r];if(t(n,r))return n}},e.assign=function(e){for(var t,r,i=e,n=arguments.length,s=new Array(n>1?n-1:0),a=1;a<n;a++)s[a-1]=arguments[a];if(Object.assign)return Object.assign.apply(Object,[e].concat(s));var o=function(){var e=s[t];"object"==typeof e&&null!==e&&Object.keys(e).forEach((function(t){i[t]=e[t]}))};for(t=0,r=s.length;t<r;t+=1)o();return e},e.getBrowserAlias=function(e){return i.BROWSER_ALIASES_MAP[e]},e.getBrowserTypeByAlias=function(e){return i.BROWSER_MAP[e]||""},e}();t.default=n,e.exports=t.default},18:function(e,t,r){"use strict";t.__esModule=!0,t.ENGINE_MAP=t.OS_MAP=t.PLATFORMS_MAP=t.BROWSER_MAP=t.BROWSER_ALIASES_MAP=void 0;t.BROWSER_ALIASES_MAP={"Amazon Silk":"amazon_silk","Android Browser":"android",Bada:"bada",BlackBerry:"blackberry",Chrome:"chrome",Chromium:"chromium",Electron:"electron",Epiphany:"epiphany",Firefox:"firefox",Focus:"focus",Generic:"generic","Google Search":"google_search",Googlebot:"googlebot","Internet Explorer":"ie","K-Meleon":"k_meleon",Maxthon:"maxthon","Microsoft Edge":"edge","MZ Browser":"mz","NAVER Whale Browser":"naver",Opera:"opera","Opera Coast":"opera_coast","Pale Moon":"pale_moon",PhantomJS:"phantomjs",Puffin:"puffin",QupZilla:"qupzilla",QQ:"qq",QQLite:"qqlite",Safari:"safari",Sailfish:"sailfish","Samsung Internet for Android":"samsung_internet",SeaMonkey:"seamonkey",Sleipnir:"sleipnir",Swing:"swing",Tizen:"tizen","UC Browser":"uc",Vivaldi:"vivaldi","WebOS Browser":"webos",WeChat:"wechat","Yandex Browser":"yandex",Roku:"roku"};t.BROWSER_MAP={amazon_silk:"Amazon Silk",android:"Android Browser",bada:"Bada",blackberry:"BlackBerry",chrome:"Chrome",chromium:"Chromium",electron:"Electron",epiphany:"Epiphany",firefox:"Firefox",focus:"Focus",generic:"Generic",googlebot:"Googlebot",google_search:"Google Search",ie:"Internet Explorer",k_meleon:"K-Meleon",maxthon:"Maxthon",edge:"Microsoft Edge",mz:"MZ Browser",naver:"NAVER Whale Browser",opera:"Opera",opera_coast:"Opera Coast",pale_moon:"Pale Moon",phantomjs:"PhantomJS",puffin:"Puffin",qupzilla:"QupZilla",qq:"QQ Browser",qqlite:"QQ Browser Lite",safari:"Safari",sailfish:"Sailfish",samsung_internet:"Samsung Internet for Android",seamonkey:"SeaMonkey",sleipnir:"Sleipnir",swing:"Swing",tizen:"Tizen",uc:"UC Browser",vivaldi:"Vivaldi",webos:"WebOS Browser",wechat:"WeChat",yandex:"Yandex Browser"};t.PLATFORMS_MAP={tablet:"tablet",mobile:"mobile",desktop:"desktop",tv:"tv",bot:"bot"};t.OS_MAP={WindowsPhone:"Windows Phone",Windows:"Windows",MacOS:"macOS",iOS:"iOS",Android:"Android",WebOS:"WebOS",BlackBerry:"BlackBerry",Bada:"Bada",Tizen:"Tizen",Linux:"Linux",ChromeOS:"Chrome OS",PlayStation4:"PlayStation 4",Roku:"Roku"};t.ENGINE_MAP={EdgeHTML:"EdgeHTML",Blink:"Blink",Trident:"Trident",Presto:"Presto",Gecko:"Gecko",WebKit:"WebKit"}},90:function(e,t,r){"use strict";t.__esModule=!0,t.default=void 0;var i,n=(i=r(91))&&i.__esModule?i:{default:i},s=r(18);function a(e,t){for(var r=0;r<t.length;r++){var i=t[r];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(e,i.key,i)}}var o=function(){function e(){}var t,r,i;return e.getParser=function(e,t){if(void 0===t&&(t=!1),"string"!=typeof e)throw new Error("UserAgent should be a string");return new n.default(e,t)},e.parse=function(e){return new n.default(e).getResult()},t=e,i=[{key:"BROWSER_MAP",get:function(){return s.BROWSER_MAP}},{key:"ENGINE_MAP",get:function(){return s.ENGINE_MAP}},{key:"OS_MAP",get:function(){return s.OS_MAP}},{key:"PLATFORMS_MAP",get:function(){return s.PLATFORMS_MAP}}],(r=null)&&a(t.prototype,r),i&&a(t,i),e}();t.default=o,e.exports=t.default},91:function(e,t,r){"use strict";t.__esModule=!0,t.default=void 0;var i=u(r(92)),n=u(r(93)),s=u(r(94)),a=u(r(95)),o=u(r(17));function u(e){return e&&e.__esModule?e:{default:e}}var d=function(){function e(e,t){if(void 0===t&&(t=!1),null==e||""===e)throw new Error("UserAgent parameter can't be empty");this._ua=e,this.parsedResult={},!0!==t&&this.parse()}var t=e.prototype;return t.getUA=function(){return this._ua},t.test=function(e){return e.test(this._ua)},t.parseBrowser=function(){var e=this;this.parsedResult.browser={};var t=o.default.find(i.default,(function(t){if("function"==typeof t.test)return t.test(e);if(Array.isArray(t.test))return t.test.some((function(t){return e.test(t)}));throw new Error("Browser's test function is not valid")}));return t&&(this.parsedResult.browser=t.describe(this.getUA())),this.parsedResult.browser},t.getBrowser=function(){return this.parsedResult.browser?this.parsedResult.browser:this.parseBrowser()},t.getBrowserName=function(e){return e?String(this.getBrowser().name).toLowerCase()||"":this.getBrowser().name||""},t.getBrowserVersion=function(){return this.getBrowser().version},t.getOS=function(){return this.parsedResult.os?this.parsedResult.os:this.parseOS()},t.parseOS=function(){var e=this;this.parsedResult.os={};var t=o.default.find(n.default,(function(t){if("function"==typeof t.test)return t.test(e);if(Array.isArray(t.test))return t.test.some((function(t){return e.test(t)}));throw new Error("Browser's test function is not valid")}));return t&&(this.parsedResult.os=t.describe(this.getUA())),this.parsedResult.os},t.getOSName=function(e){var t=this.getOS().name;return e?String(t).toLowerCase()||"":t||""},t.getOSVersion=function(){return this.getOS().version},t.getPlatform=function(){return this.parsedResult.platform?this.parsedResult.platform:this.parsePlatform()},t.getPlatformType=function(e){void 0===e&&(e=!1);var t=this.getPlatform().type;return e?String(t).toLowerCase()||"":t||""},t.parsePlatform=function(){var e=this;this.parsedResult.platform={};var t=o.default.find(s.default,(function(t){if("function"==typeof t.test)return t.test(e);if(Array.isArray(t.test))return t.test.some((function(t){return e.test(t)}));throw new Error("Browser's test function is not valid")}));return t&&(this.parsedResult.platform=t.describe(this.getUA())),this.parsedResult.platform},t.getEngine=function(){return this.parsedResult.engine?this.parsedResult.engine:this.parseEngine()},t.getEngineName=function(e){return e?String(this.getEngine().name).toLowerCase()||"":this.getEngine().name||""},t.parseEngine=function(){var e=this;this.parsedResult.engine={};var t=o.default.find(a.default,(function(t){if("function"==typeof t.test)return t.test(e);if(Array.isArray(t.test))return t.test.some((function(t){return e.test(t)}));throw new Error("Browser's test function is not valid")}));return t&&(this.parsedResult.engine=t.describe(this.getUA())),this.parsedResult.engine},t.parse=function(){return this.parseBrowser(),this.parseOS(),this.parsePlatform(),this.parseEngine(),this},t.getResult=function(){return o.default.assign({},this.parsedResult)},t.satisfies=function(e){var t=this,r={},i=0,n={},s=0;if(Object.keys(e).forEach((function(t){var a=e[t];"string"==typeof a?(n[t]=a,s+=1):"object"==typeof a&&(r[t]=a,i+=1)})),i>0){var a=Object.keys(r),u=o.default.find(a,(function(e){return t.isOS(e)}));if(u){var d=this.satisfies(r[u]);if(void 0!==d)return d}var c=o.default.find(a,(function(e){return t.isPlatform(e)}));if(c){var f=this.satisfies(r[c]);if(void 0!==f)return f}}if(s>0){var l=Object.keys(n),h=o.default.find(l,(function(e){return t.isBrowser(e,!0)}));if(void 0!==h)return this.compareVersion(n[h])}},t.isBrowser=function(e,t){void 0===t&&(t=!1);var r=this.getBrowserName().toLowerCase(),i=e.toLowerCase(),n=o.default.getBrowserTypeByAlias(i);return t&&n&&(i=n.toLowerCase()),i===r},t.compareVersion=function(e){var t=[0],r=e,i=!1,n=this.getBrowserVersion();if("string"==typeof n)return">"===e[0]||"<"===e[0]?(r=e.substr(1),"="===e[1]?(i=!0,r=e.substr(2)):t=[],">"===e[0]?t.push(1):t.push(-1)):"="===e[0]?r=e.substr(1):"~"===e[0]&&(i=!0,r=e.substr(1)),t.indexOf(o.default.compareVersions(n,r,i))>-1},t.isOS=function(e){return this.getOSName(!0)===String(e).toLowerCase()},t.isPlatform=function(e){return this.getPlatformType(!0)===String(e).toLowerCase()},t.isEngine=function(e){return this.getEngineName(!0)===String(e).toLowerCase()},t.is=function(e,t){return void 0===t&&(t=!1),this.isBrowser(e,t)||this.isOS(e)||this.isPlatform(e)},t.some=function(e){var t=this;return void 0===e&&(e=[]),e.some((function(e){return t.is(e)}))},e}();t.default=d,e.exports=t.default},92:function(e,t,r){"use strict";t.__esModule=!0,t.default=void 0;var i,n=(i=r(17))&&i.__esModule?i:{default:i};var s=/version\/(\d+(\.?_?\d+)+)/i,a=[{test:[/googlebot/i],describe:function(e){var t={name:"Googlebot"},r=n.default.getFirstMatch(/googlebot\/(\d+(\.\d+))/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/opera/i],describe:function(e){var t={name:"Opera"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:opera)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/opr\/|opios/i],describe:function(e){var t={name:"Opera"},r=n.default.getFirstMatch(/(?:opr|opios)[\s/](\S+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/SamsungBrowser/i],describe:function(e){var t={name:"Samsung Internet for Android"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:SamsungBrowser)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/Whale/i],describe:function(e){var t={name:"NAVER Whale Browser"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:whale)[\s/](\d+(?:\.\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/PaleMoon/i],describe:function(e){var t={name:"Pale Moon"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:PaleMoon)[\s/](\d+(?:\.\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/MZBrowser/i],describe:function(e){var t={name:"MZ Browser"},r=n.default.getFirstMatch(/(?:MZBrowser)[\s/](\d+(?:\.\d+)+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/focus/i],describe:function(e){var t={name:"Focus"},r=n.default.getFirstMatch(/(?:focus)[\s/](\d+(?:\.\d+)+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/swing/i],describe:function(e){var t={name:"Swing"},r=n.default.getFirstMatch(/(?:swing)[\s/](\d+(?:\.\d+)+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/coast/i],describe:function(e){var t={name:"Opera Coast"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:coast)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/opt\/\d+(?:.?_?\d+)+/i],describe:function(e){var t={name:"Opera Touch"},r=n.default.getFirstMatch(/(?:opt)[\s/](\d+(\.?_?\d+)+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/yabrowser/i],describe:function(e){var t={name:"Yandex Browser"},r=n.default.getFirstMatch(/(?:yabrowser)[\s/](\d+(\.?_?\d+)+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/ucbrowser/i],describe:function(e){var t={name:"UC Browser"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:ucbrowser)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/Maxthon|mxios/i],describe:function(e){var t={name:"Maxthon"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:Maxthon|mxios)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/epiphany/i],describe:function(e){var t={name:"Epiphany"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:epiphany)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/puffin/i],describe:function(e){var t={name:"Puffin"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:puffin)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/sleipnir/i],describe:function(e){var t={name:"Sleipnir"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:sleipnir)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/k-meleon/i],describe:function(e){var t={name:"K-Meleon"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/(?:k-meleon)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/micromessenger/i],describe:function(e){var t={name:"WeChat"},r=n.default.getFirstMatch(/(?:micromessenger)[\s/](\d+(\.?_?\d+)+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/qqbrowser/i],describe:function(e){var t={name:/qqbrowserlite/i.test(e)?"QQ Browser Lite":"QQ Browser"},r=n.default.getFirstMatch(/(?:qqbrowserlite|qqbrowser)[/](\d+(\.?_?\d+)+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/msie|trident/i],describe:function(e){var t={name:"Internet Explorer"},r=n.default.getFirstMatch(/(?:msie |rv:)(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/\sedg\//i],describe:function(e){var t={name:"Microsoft Edge"},r=n.default.getFirstMatch(/\sedg\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/edg([ea]|ios)/i],describe:function(e){var t={name:"Microsoft Edge"},r=n.default.getSecondMatch(/edg([ea]|ios)\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/vivaldi/i],describe:function(e){var t={name:"Vivaldi"},r=n.default.getFirstMatch(/vivaldi\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/seamonkey/i],describe:function(e){var t={name:"SeaMonkey"},r=n.default.getFirstMatch(/seamonkey\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/sailfish/i],describe:function(e){var t={name:"Sailfish"},r=n.default.getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i,e);return r&&(t.version=r),t}},{test:[/silk/i],describe:function(e){var t={name:"Amazon Silk"},r=n.default.getFirstMatch(/silk\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/phantom/i],describe:function(e){var t={name:"PhantomJS"},r=n.default.getFirstMatch(/phantomjs\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/slimerjs/i],describe:function(e){var t={name:"SlimerJS"},r=n.default.getFirstMatch(/slimerjs\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/blackberry|\bbb\d+/i,/rim\stablet/i],describe:function(e){var t={name:"BlackBerry"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/blackberry[\d]+\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/(web|hpw)[o0]s/i],describe:function(e){var t={name:"WebOS Browser"},r=n.default.getFirstMatch(s,e)||n.default.getFirstMatch(/w(?:eb)?[o0]sbrowser\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/bada/i],describe:function(e){var t={name:"Bada"},r=n.default.getFirstMatch(/dolfin\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/tizen/i],describe:function(e){var t={name:"Tizen"},r=n.default.getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.?_?\d+)+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/qupzilla/i],describe:function(e){var t={name:"QupZilla"},r=n.default.getFirstMatch(/(?:qupzilla)[\s/](\d+(\.?_?\d+)+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/firefox|iceweasel|fxios/i],describe:function(e){var t={name:"Firefox"},r=n.default.getFirstMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/electron/i],describe:function(e){var t={name:"Electron"},r=n.default.getFirstMatch(/(?:electron)\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/MiuiBrowser/i],describe:function(e){var t={name:"Miui"},r=n.default.getFirstMatch(/(?:MiuiBrowser)[\s/](\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/chromium/i],describe:function(e){var t={name:"Chromium"},r=n.default.getFirstMatch(/(?:chromium)[\s/](\d+(\.?_?\d+)+)/i,e)||n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/chrome|crios|crmo/i],describe:function(e){var t={name:"Chrome"},r=n.default.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/GSA/i],describe:function(e){var t={name:"Google Search"},r=n.default.getFirstMatch(/(?:GSA)\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:function(e){var t=!e.test(/like android/i),r=e.test(/android/i);return t&&r},describe:function(e){var t={name:"Android Browser"},r=n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/playstation 4/i],describe:function(e){var t={name:"PlayStation 4"},r=n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/safari|applewebkit/i],describe:function(e){var t={name:"Safari"},r=n.default.getFirstMatch(s,e);return r&&(t.version=r),t}},{test:[/.*/i],describe:function(e){var t=-1!==e.search("\\(")?/^(.*)\/(.*)[ \t]\((.*)/:/^(.*)\/(.*) /;return{name:n.default.getFirstMatch(t,e),version:n.default.getSecondMatch(t,e)}}}];t.default=a,e.exports=t.default},93:function(e,t,r){"use strict";t.__esModule=!0,t.default=void 0;var i,n=(i=r(17))&&i.__esModule?i:{default:i},s=r(18);var a=[{test:[/Roku\/DVP/],describe:function(e){var t=n.default.getFirstMatch(/Roku\/DVP-(\d+\.\d+)/i,e);return{name:s.OS_MAP.Roku,version:t}}},{test:[/windows phone/i],describe:function(e){var t=n.default.getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i,e);return{name:s.OS_MAP.WindowsPhone,version:t}}},{test:[/windows /i],describe:function(e){var t=n.default.getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i,e),r=n.default.getWindowsVersionName(t);return{name:s.OS_MAP.Windows,version:t,versionName:r}}},{test:[/Macintosh(.*?) FxiOS(.*?)\//],describe:function(e){var t={name:s.OS_MAP.iOS},r=n.default.getSecondMatch(/(Version\/)(\d[\d.]+)/,e);return r&&(t.version=r),t}},{test:[/macintosh/i],describe:function(e){var t=n.default.getFirstMatch(/mac os x (\d+(\.?_?\d+)+)/i,e).replace(/[_\s]/g,"."),r=n.default.getMacOSVersionName(t),i={name:s.OS_MAP.MacOS,version:t};return r&&(i.versionName=r),i}},{test:[/(ipod|iphone|ipad)/i],describe:function(e){var t=n.default.getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i,e).replace(/[_\s]/g,".");return{name:s.OS_MAP.iOS,version:t}}},{test:function(e){var t=!e.test(/like android/i),r=e.test(/android/i);return t&&r},describe:function(e){var t=n.default.getFirstMatch(/android[\s/-](\d+(\.\d+)*)/i,e),r=n.default.getAndroidVersionName(t),i={name:s.OS_MAP.Android,version:t};return r&&(i.versionName=r),i}},{test:[/(web|hpw)[o0]s/i],describe:function(e){var t=n.default.getFirstMatch(/(?:web|hpw)[o0]s\/(\d+(\.\d+)*)/i,e),r={name:s.OS_MAP.WebOS};return t&&t.length&&(r.version=t),r}},{test:[/blackberry|\bbb\d+/i,/rim\stablet/i],describe:function(e){var t=n.default.getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i,e)||n.default.getFirstMatch(/blackberry\d+\/(\d+([_\s]\d+)*)/i,e)||n.default.getFirstMatch(/\bbb(\d+)/i,e);return{name:s.OS_MAP.BlackBerry,version:t}}},{test:[/bada/i],describe:function(e){var t=n.default.getFirstMatch(/bada\/(\d+(\.\d+)*)/i,e);return{name:s.OS_MAP.Bada,version:t}}},{test:[/tizen/i],describe:function(e){var t=n.default.getFirstMatch(/tizen[/\s](\d+(\.\d+)*)/i,e);return{name:s.OS_MAP.Tizen,version:t}}},{test:[/linux/i],describe:function(){return{name:s.OS_MAP.Linux}}},{test:[/CrOS/],describe:function(){return{name:s.OS_MAP.ChromeOS}}},{test:[/PlayStation 4/],describe:function(e){var t=n.default.getFirstMatch(/PlayStation 4[/\s](\d+(\.\d+)*)/i,e);return{name:s.OS_MAP.PlayStation4,version:t}}}];t.default=a,e.exports=t.default},94:function(e,t,r){"use strict";t.__esModule=!0,t.default=void 0;var i,n=(i=r(17))&&i.__esModule?i:{default:i},s=r(18);var a=[{test:[/googlebot/i],describe:function(){return{type:s.PLATFORMS_MAP.bot,vendor:"Google"}}},{test:[/huawei/i],describe:function(e){var t=n.default.getFirstMatch(/(can-l01)/i,e)&&"Nova",r={type:s.PLATFORMS_MAP.mobile,vendor:"Huawei"};return t&&(r.model=t),r}},{test:[/nexus\s*(?:7|8|9|10).*/i],describe:function(){return{type:s.PLATFORMS_MAP.tablet,vendor:"Nexus"}}},{test:[/ipad/i],describe:function(){return{type:s.PLATFORMS_MAP.tablet,vendor:"Apple",model:"iPad"}}},{test:[/Macintosh(.*?) FxiOS(.*?)\//],describe:function(){return{type:s.PLATFORMS_MAP.tablet,vendor:"Apple",model:"iPad"}}},{test:[/kftt build/i],describe:function(){return{type:s.PLATFORMS_MAP.tablet,vendor:"Amazon",model:"Kindle Fire HD 7"}}},{test:[/silk/i],describe:function(){return{type:s.PLATFORMS_MAP.tablet,vendor:"Amazon"}}},{test:[/tablet(?! pc)/i],describe:function(){return{type:s.PLATFORMS_MAP.tablet}}},{test:function(e){var t=e.test(/ipod|iphone/i),r=e.test(/like (ipod|iphone)/i);return t&&!r},describe:function(e){var t=n.default.getFirstMatch(/(ipod|iphone)/i,e);return{type:s.PLATFORMS_MAP.mobile,vendor:"Apple",model:t}}},{test:[/nexus\s*[0-6].*/i,/galaxy nexus/i],describe:function(){return{type:s.PLATFORMS_MAP.mobile,vendor:"Nexus"}}},{test:[/Nokia/i],describe:function(e){var t=n.default.getFirstMatch(/Nokia\s+([0-9]+(\.[0-9]+)?)/i,e),r={type:s.PLATFORMS_MAP.mobile,vendor:"Nokia"};return t&&(r.model=t),r}},{test:[/[^-]mobi/i],describe:function(){return{type:s.PLATFORMS_MAP.mobile}}},{test:function(e){return"blackberry"===e.getBrowserName(!0)},describe:function(){return{type:s.PLATFORMS_MAP.mobile,vendor:"BlackBerry"}}},{test:function(e){return"bada"===e.getBrowserName(!0)},describe:function(){return{type:s.PLATFORMS_MAP.mobile}}},{test:function(e){return"windows phone"===e.getBrowserName()},describe:function(){return{type:s.PLATFORMS_MAP.mobile,vendor:"Microsoft"}}},{test:function(e){var t=Number(String(e.getOSVersion()).split(".")[0]);return"android"===e.getOSName(!0)&&t>=3},describe:function(){return{type:s.PLATFORMS_MAP.tablet}}},{test:function(e){return"android"===e.getOSName(!0)},describe:function(){return{type:s.PLATFORMS_MAP.mobile}}},{test:function(e){return"macos"===e.getOSName(!0)},describe:function(){return{type:s.PLATFORMS_MAP.desktop,vendor:"Apple"}}},{test:function(e){return"windows"===e.getOSName(!0)},describe:function(){return{type:s.PLATFORMS_MAP.desktop}}},{test:function(e){return"linux"===e.getOSName(!0)},describe:function(){return{type:s.PLATFORMS_MAP.desktop}}},{test:function(e){return"playstation 4"===e.getOSName(!0)},describe:function(){return{type:s.PLATFORMS_MAP.tv}}},{test:function(e){return"roku"===e.getOSName(!0)},describe:function(){return{type:s.PLATFORMS_MAP.tv}}}];t.default=a,e.exports=t.default},95:function(e,t,r){"use strict";t.__esModule=!0,t.default=void 0;var i,n=(i=r(17))&&i.__esModule?i:{default:i},s=r(18);var a=[{test:function(e){return"microsoft edge"===e.getBrowserName(!0)},describe:function(e){if(/\sedg\//i.test(e))return{name:s.ENGINE_MAP.Blink};var t=n.default.getFirstMatch(/edge\/(\d+(\.?_?\d+)+)/i,e);return{name:s.ENGINE_MAP.EdgeHTML,version:t}}},{test:[/trident/i],describe:function(e){var t={name:s.ENGINE_MAP.Trident},r=n.default.getFirstMatch(/trident\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:function(e){return e.test(/presto/i)},describe:function(e){var t={name:s.ENGINE_MAP.Presto},r=n.default.getFirstMatch(/presto\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:function(e){var t=e.test(/gecko/i),r=e.test(/like gecko/i);return t&&!r},describe:function(e){var t={name:s.ENGINE_MAP.Gecko},r=n.default.getFirstMatch(/gecko\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}},{test:[/(apple)?webkit\/537\.36/i],describe:function(){return{name:s.ENGINE_MAP.Blink}}},{test:[/(apple)?webkit/i],describe:function(e){var t={name:s.ENGINE_MAP.WebKit},r=n.default.getFirstMatch(/webkit\/(\d+(\.?_?\d+)+)/i,e);return r&&(t.version=r),t}}];t.default=a,e.exports=t.default}})})); 20359 20360/***/ }), 20361
vendor: 49,030 bytes, lines 20362-22161
20362/***/ "./node_modules/buffer/index.js": 20363/*!**************************************!*\ 20364 !*** ./node_modules/buffer/index.js ***! 20365 \**************************************/ 20366/***/ ((__unused_webpack_module, exports, __webpack_require__) => { 20367 20368"use strict"; 20369/*! 20370 * The buffer module from node.js, for the browser. 20371 * 20372 * @author Feross Aboukhadijeh <http://feross.org> 20373 * @license MIT 20374 */ 20375/* eslint-disable no-proto */ 20376 20377 20378 20379var base64 = __webpack_require__(/*! base64-js */ "./node_modules/base64-js/index.js") 20380var ieee754 = __webpack_require__(/*! ieee754 */ "./node_modules/ieee754/index.js") 20381var isArray = __webpack_require__(/*! isarray */ "./node_modules/isarray/index.js") 20382 20383exports.Buffer = Buffer 20384exports.SlowBuffer = SlowBuffer 20385exports.INSPECT_MAX_BYTES = 50 20386 20387/** 20388 * If `Buffer.TYPED_ARRAY_SUPPORT`: 20389 * === true Use Uint8Array implementation (fastest) 20390 * === false Use Object implementation (most compatible, even IE6) 20391 * 20392 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, 20393 * Opera 11.6+, iOS 4.2+. 20394 * 20395 * Due to various browser bugs, sometimes the Object implementation will be used even 20396 * when the browser supports typed arrays. 20397 * 20398 * Note: 20399 * 20400 * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, 20401 * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. 20402 * 20403 * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. 20404 * 20405 * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of 20406 * incorrect length in some situations. 20407 20408 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they 20409 * get the Object implementation, which is slower but behaves correctly. 20410 */ 20411Buffer.TYPED_ARRAY_SUPPORT = __webpack_require__.g.TYPED_ARRAY_SUPPORT !== undefined 20412 ? __webpack_require__.g.TYPED_ARRAY_SUPPORT 20413 : typedArraySupport() 20414 20415/* 20416 * Export kMaxLength after typed array support is determined. 20417 */ 20418exports.kMaxLength = kMaxLength() 20419 20420function typedArraySupport () { 20421 try { 20422 var arr = new Uint8Array(1) 20423 arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }} 20424 return arr.foo() === 42 && // typed array instances can be augmented 20425 typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` 20426 arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` 20427 } catch (e) { 20428 return false 20429 } 20430} 20431 20432function kMaxLength () { 20433 return Buffer.TYPED_ARRAY_SUPPORT 20434 ? 0x7fffffff 20435 : 0x3fffffff 20436} 20437 20438function createBuffer (that, length) { 20439 if (kMaxLength() < length) { 20440 throw new RangeError('Invalid typed array length') 20441 } 20442 if (Buffer.TYPED_ARRAY_SUPPORT) { 20443 // Return an augmented `Uint8Array` instance, for best performance 20444 that = new Uint8Array(length) 20445 that.__proto__ = Buffer.prototype 20446 } else { 20447 // Fallback: Return an object instance of the Buffer class 20448 if (that === null) { 20449 that = new Buffer(length) 20450 } 20451 that.length = length 20452 } 20453 20454 return that 20455} 20456 20457/** 20458 * The Buffer constructor returns instances of `Uint8Array` that have their 20459 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of 20460 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods 20461 * and the `Uint8Array` methods. Square bracket notation works as expected -- it 20462 * returns a single octet. 20463 * 20464 * The `Uint8Array` prototype remains unmodified. 20465 */ 20466 20467function Buffer (arg, encodingOrOffset, length) { 20468 if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { 20469 return new Buffer(arg, encodingOrOffset, length) 20470 } 20471 20472 // Common case. 20473 if (typeof arg === 'number') { 20474 if (typeof encodingOrOffset === 'string') { 20475 throw new Error( 20476 'If encoding is specified then the first argument must be a string' 20477 ) 20478 } 20479 return allocUnsafe(this, arg) 20480 } 20481 return from(this, arg, encodingOrOffset, length) 20482} 20483 20484Buffer.poolSize = 8192 // not used by this implementation 20485 20486// TODO: Legacy, not needed anymore. Remove in next major version. 20487Buffer._augment = function (arr) { 20488 arr.__proto__ = Buffer.prototype 20489 return arr 20490} 20491 20492function from (that, value, encodingOrOffset, length) { 20493 if (typeof value === 'number') { 20494 throw new TypeError('"value" argument must not be a number') 20495 } 20496 20497 if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { 20498 return fromArrayBuffer(that, value, encodingOrOffset, length) 20499 } 20500 20501 if (typeof value === 'string') { 20502 return fromString(that, value, encodingOrOffset) 20503 } 20504 20505 return fromObject(that, value) 20506} 20507 20508/** 20509 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError 20510 * if value is a number. 20511 * Buffer.from(str[, encoding]) 20512 * Buffer.from(array) 20513 * Buffer.from(buffer) 20514 * Buffer.from(arrayBuffer[, byteOffset[, length]]) 20515 **/ 20516Buffer.from = function (value, encodingOrOffset, length) { 20517 return from(null, value, encodingOrOffset, length) 20518} 20519 20520if (Buffer.TYPED_ARRAY_SUPPORT) { 20521 Buffer.prototype.__proto__ = Uint8Array.prototype 20522 Buffer.__proto__ = Uint8Array 20523 if (typeof Symbol !== 'undefined' && Symbol.species && 20524 Buffer[Symbol.species] === Buffer) { 20525 // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 20526 Object.defineProperty(Buffer, Symbol.species, { 20527 value: null, 20528 configurable: true 20529 }) 20530 } 20531} 20532 20533function assertSize (size) { 20534 if (typeof size !== 'number') { 20535 throw new TypeError('"size" argument must be a number') 20536 } else if (size < 0) { 20537 throw new RangeError('"size" argument must not be negative') 20538 } 20539} 20540 20541function alloc (that, size, fill, encoding) { 20542 assertSize(size) 20543 if (size <= 0) { 20544 return createBuffer(that, size) 20545 } 20546 if (fill !== undefined) { 20547 // Only pay attention to encoding if it's a string. This 20548 // prevents accidentally sending in a number that would 20549 // be interpretted as a start offset. 20550 return typeof encoding === 'string' 20551 ? createBuffer(that, size).fill(fill, encoding) 20552 : createBuffer(that, size).fill(fill) 20553 } 20554 return createBuffer(that, size) 20555} 20556 20557/** 20558 * Creates a new filled Buffer instance. 20559 * alloc(size[, fill[, encoding]]) 20560 **/ 20561Buffer.alloc = function (size, fill, encoding) { 20562 return alloc(null, size, fill, encoding) 20563} 20564 20565function allocUnsafe (that, size) { 20566 assertSize(size) 20567 that = createBuffer(that, size < 0 ? 0 : checked(size) | 0) 20568 if (!Buffer.TYPED_ARRAY_SUPPORT) { 20569 for (var i = 0; i < size; ++i) { 20570 that[i] = 0 20571 } 20572 } 20573 return that 20574} 20575 20576/** 20577 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. 20578 * */ 20579Buffer.allocUnsafe = function (size) { 20580 return allocUnsafe(null, size) 20581} 20582/** 20583 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. 20584 */ 20585Buffer.allocUnsafeSlow = function (size) { 20586 return allocUnsafe(null, size) 20587} 20588 20589function fromString (that, string, encoding) { 20590 if (typeof encoding !== 'string' || encoding === '') { 20591 encoding = 'utf8' 20592 } 20593 20594 if (!Buffer.isEncoding(encoding)) { 20595 throw new TypeError('"encoding" must be a valid string encoding') 20596 } 20597 20598 var length = byteLength(string, encoding) | 0 20599 that = createBuffer(that, length) 20600 20601 var actual = that.write(string, encoding) 20602 20603 if (actual !== length) { 20604 // Writing a hex string, for example, that contains invalid characters will 20605 // cause everything after the first invalid character to be ignored. (e.g. 20606 // 'abxxcd' will be treated as 'ab') 20607 that = that.slice(0, actual) 20608 } 20609 20610 return that 20611} 20612 20613function fromArrayLike (that, array) { 20614 var length = array.length < 0 ? 0 : checked(array.length) | 0 20615 that = createBuffer(that, length) 20616 for (var i = 0; i < length; i += 1) { 20617 that[i] = array[i] & 255 20618 } 20619 return that 20620} 20621 20622function fromArrayBuffer (that, array, byteOffset, length) { 20623 array.byteLength // this throws if `array` is not a valid ArrayBuffer 20624 20625 if (byteOffset < 0 || array.byteLength < byteOffset) { 20626 throw new RangeError('\'offset\' is out of bounds') 20627 } 20628 20629 if (array.byteLength < byteOffset + (length || 0)) { 20630 throw new RangeError('\'length\' is out of bounds') 20631 } 20632 20633 if (byteOffset === undefined && length === undefined) { 20634 array = new Uint8Array(array) 20635 } else if (length === undefined) { 20636 array = new Uint8Array(array, byteOffset) 20637 } else { 20638 array = new Uint8Array(array, byteOffset, length) 20639 } 20640 20641 if (Buffer.TYPED_ARRAY_SUPPORT) { 20642 // Return an augmented `Uint8Array` instance, for best performance 20643 that = array 20644 that.__proto__ = Buffer.prototype 20645 } else { 20646 // Fallback: Return an object instance of the Buffer class 20647 that = fromArrayLike(that, array) 20648 } 20649 return that 20650} 20651 20652function fromObject (that, obj) { 20653 if (Buffer.isBuffer(obj)) { 20654 var len = checked(obj.length) | 0 20655 that = createBuffer(that, len) 20656 20657 if (that.length === 0) { 20658 return that 20659 } 20660 20661 obj.copy(that, 0, 0, len) 20662 return that 20663 } 20664 20665 if (obj) { 20666 if ((typeof ArrayBuffer !== 'undefined' && 20667 obj.buffer instanceof ArrayBuffer) || 'length' in obj) { 20668 if (typeof obj.length !== 'number' || isnan(obj.length)) { 20669 return createBuffer(that, 0) 20670 } 20671 return fromArrayLike(that, obj) 20672 } 20673 20674 if (obj.type === 'Buffer' && isArray(obj.data)) { 20675 return fromArrayLike(that, obj.data) 20676 } 20677 } 20678 20679 throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') 20680} 20681 20682function checked (length) { 20683 // Note: cannot use `length < kMaxLength()` here because that fails when 20684 // length is NaN (which is otherwise coerced to zero.) 20685 if (length >= kMaxLength()) { 20686 throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 20687 'size: 0x' + kMaxLength().toString(16) + ' bytes') 20688 } 20689 return length | 0 20690} 20691 20692function SlowBuffer (length) { 20693 if (+length != length) { // eslint-disable-line eqeqeq 20694 length = 0 20695 } 20696 return Buffer.alloc(+length) 20697} 20698 20699Buffer.isBuffer = function isBuffer (b) { 20700 return !!(b != null && b._isBuffer) 20701} 20702 20703Buffer.compare = function compare (a, b) { 20704 if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { 20705 throw new TypeError('Arguments must be Buffers') 20706 } 20707 20708 if (a === b) return 0 20709 20710 var x = a.length 20711 var y = b.length 20712 20713 for (var i = 0, len = Math.min(x, y); i < len; ++i) { 20714 if (a[i] !== b[i]) { 20715 x = a[i] 20716 y = b[i] 20717 break 20718 } 20719 } 20720 20721 if (x < y) return -1 20722 if (y < x) return 1 20723 return 0 20724} 20725 20726Buffer.isEncoding = function isEncoding (encoding) { 20727 switch (String(encoding).toLowerCase()) { 20728 case 'hex': 20729 case 'utf8': 20730 case 'utf-8': 20731 case 'ascii': 20732 case 'latin1': 20733 case 'binary': 20734 case 'base64': 20735 case 'ucs2': 20736 case 'ucs-2': 20737 case 'utf16le': 20738 case 'utf-16le': 20739 return true 20740 default: 20741 return false 20742 } 20743} 20744 20745Buffer.concat = function concat (list, length) { 20746 if (!isArray(list)) { 20747 throw new TypeError('"list" argument must be an Array of Buffers') 20748 } 20749 20750 if (list.length === 0) { 20751 return Buffer.alloc(0) 20752 } 20753 20754 var i 20755 if (length === undefined) { 20756 length = 0 20757 for (i = 0; i < list.length; ++i) { 20758 length += list[i].length 20759 } 20760 } 20761 20762 var buffer = Buffer.allocUnsafe(length) 20763 var pos = 0 20764 for (i = 0; i < list.length; ++i) { 20765 var buf = list[i] 20766 if (!Buffer.isBuffer(buf)) { 20767 throw new TypeError('"list" argument must be an Array of Buffers') 20768 } 20769 buf.copy(buffer, pos) 20770 pos += buf.length 20771 } 20772 return buffer 20773} 20774 20775function byteLength (string, encoding) { 20776 if (Buffer.isBuffer(string)) { 20777 return string.length 20778 } 20779 if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && 20780 (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { 20781 return string.byteLength 20782 } 20783 if (typeof string !== 'string') { 20784 string = '' + string 20785 } 20786 20787 var len = string.length 20788 if (len === 0) return 0 20789 20790 // Use a for loop to avoid recursion 20791 var loweredCase = false 20792 for (;;) { 20793 switch (encoding) { 20794 case 'ascii': 20795 case 'latin1': 20796 case 'binary': 20797 return len 20798 case 'utf8': 20799 case 'utf-8': 20800 case undefined: 20801 return utf8ToBytes(string).length 20802 case 'ucs2': 20803 case 'ucs-2': 20804 case 'utf16le': 20805 case 'utf-16le': 20806 return len * 2 20807 case 'hex': 20808 return len >>> 1 20809 case 'base64': 20810 return base64ToBytes(string).length 20811 default: 20812 if (loweredCase) return utf8ToBytes(string).length // assume utf8 20813 encoding = ('' + encoding).toLowerCase() 20814 loweredCase = true 20815 } 20816 } 20817} 20818Buffer.byteLength = byteLength 20819 20820function slowToString (encoding, start, end) { 20821 var loweredCase = false 20822 20823 // No need to verify that "this.length <= MAX_UINT32" since it's a read-only 20824 // property of a typed array. 20825 20826 // This behaves neither like String nor Uint8Array in that we set start/end 20827 // to their upper/lower bounds if the value passed is out of range. 20828 // undefined is handled specially as per ECMA-262 6th Edition, 20829 // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. 20830 if (start === undefined || start < 0) { 20831 start = 0 20832 } 20833 // Return early if start > this.length. Done here to prevent potential uint32 20834 // coercion fail below. 20835 if (start > this.length) { 20836 return '' 20837 } 20838 20839 if (end === undefined || end > this.length) { 20840 end = this.length 20841 } 20842 20843 if (end <= 0) { 20844 return '' 20845 } 20846 20847 // Force coersion to uint32. This will also coerce falsey/NaN values to 0. 20848 end >>>= 0 20849 start >>>= 0 20850 20851 if (end <= start) { 20852 return '' 20853 } 20854 20855 if (!encoding) encoding = 'utf8' 20856 20857 while (true) { 20858 switch (encoding) { 20859 case 'hex': 20860 return hexSlice(this, start, end) 20861 20862 case 'utf8': 20863 case 'utf-8': 20864 return utf8Slice(this, start, end) 20865 20866 case 'ascii': 20867 return asciiSlice(this, start, end) 20868 20869 case 'latin1': 20870 case 'binary': 20871 return latin1Slice(this, start, end) 20872 20873 case 'base64': 20874 return base64Slice(this, start, end) 20875 20876 case 'ucs2': 20877 case 'ucs-2': 20878 case 'utf16le': 20879 case 'utf-16le': 20880 return utf16leSlice(this, start, end) 20881 20882 default: 20883 if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) 20884 encoding = (encoding + '').toLowerCase() 20885 loweredCase = true 20886 } 20887 } 20888} 20889 20890// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect 20891// Buffer instances. 20892Buffer.prototype._isBuffer = true 20893 20894function swap (b, n, m) { 20895 var i = b[n] 20896 b[n] = b[m] 20897 b[m] = i 20898} 20899 20900Buffer.prototype.swap16 = function swap16 () { 20901 var len = this.length 20902 if (len % 2 !== 0) { 20903 throw new RangeError('Buffer size must be a multiple of 16-bits') 20904 } 20905 for (var i = 0; i < len; i += 2) { 20906 swap(this, i, i + 1) 20907 } 20908 return this 20909} 20910 20911Buffer.prototype.swap32 = function swap32 () { 20912 var len = this.length 20913 if (len % 4 !== 0) { 20914 throw new RangeError('Buffer size must be a multiple of 32-bits') 20915 } 20916 for (var i = 0; i < len; i += 4) { 20917 swap(this, i, i + 3) 20918 swap(this, i + 1, i + 2) 20919 } 20920 return this 20921} 20922 20923Buffer.prototype.swap64 = function swap64 () { 20924 var len = this.length 20925 if (len % 8 !== 0) { 20926 throw new RangeError('Buffer size must be a multiple of 64-bits') 20927 } 20928 for (var i = 0; i < len; i += 8) { 20929 swap(this, i, i + 7) 20930 swap(this, i + 1, i + 6) 20931 swap(this, i + 2, i + 5) 20932 swap(this, i + 3, i + 4) 20933 } 20934 return this 20935} 20936 20937Buffer.prototype.toString = function toString () { 20938 var length = this.length | 0 20939 if (length === 0) return '' 20940 if (arguments.length === 0) return utf8Slice(this, 0, length) 20941 return slowToString.apply(this, arguments) 20942} 20943 20944Buffer.prototype.equals = function equals (b) { 20945 if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') 20946 if (this === b) return true 20947 return Buffer.compare(this, b) === 0 20948} 20949 20950Buffer.prototype.inspect = function inspect () { 20951 var str = '' 20952 var max = exports.INSPECT_MAX_BYTES 20953 if (this.length > 0) { 20954 str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') 20955 if (this.length > max) str += ' ... ' 20956 } 20957 return '<Buffer ' + str + '>' 20958} 20959 20960Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { 20961 if (!Buffer.isBuffer(target)) { 20962 throw new TypeError('Argument must be a Buffer') 20963 } 20964 20965 if (start === undefined) { 20966 start = 0 20967 } 20968 if (end === undefined) { 20969 end = target ? target.length : 0 20970 } 20971 if (thisStart === undefined) { 20972 thisStart = 0 20973 } 20974 if (thisEnd === undefined) { 20975 thisEnd = this.length 20976 } 20977 20978 if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { 20979 throw new RangeError('out of range index') 20980 } 20981 20982 if (thisStart >= thisEnd && start >= end) { 20983 return 0 20984 } 20985 if (thisStart >= thisEnd) { 20986 return -1 20987 } 20988 if (start >= end) { 20989 return 1 20990 } 20991 20992 start >>>= 0 20993 end >>>= 0 20994 thisStart >>>= 0 20995 thisEnd >>>= 0 20996 20997 if (this === target) return 0 20998 20999 var x = thisEnd - thisStart 21000 var y = end - start 21001 var len = Math.min(x, y) 21002 21003 var thisCopy = this.slice(thisStart, thisEnd) 21004 var targetCopy = target.slice(start, end) 21005 21006 for (var i = 0; i < len; ++i) { 21007 if (thisCopy[i] !== targetCopy[i]) { 21008 x = thisCopy[i] 21009 y = targetCopy[i] 21010 break 21011 } 21012 } 21013 21014 if (x < y) return -1 21015 if (y < x) return 1 21016 return 0 21017} 21018 21019// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, 21020// OR the last index of `val` in `buffer` at offset <= `byteOffset`. 21021// 21022// Arguments: 21023// - buffer - a Buffer to search 21024// - val - a string, Buffer, or number 21025// - byteOffset - an index into `buffer`; will be clamped to an int32 21026// - encoding - an optional encoding, relevant is val is a string 21027// - dir - true for indexOf, false for lastIndexOf 21028function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { 21029 // Empty buffer means no match 21030 if (buffer.length === 0) return -1 21031 21032 // Normalize byteOffset 21033 if (typeof byteOffset === 'string') { 21034 encoding = byteOffset 21035 byteOffset = 0 21036 } else if (byteOffset > 0x7fffffff) { 21037 byteOffset = 0x7fffffff 21038 } else if (byteOffset < -0x80000000) { 21039 byteOffset = -0x80000000 21040 } 21041 byteOffset = +byteOffset // Coerce to Number. 21042 if (isNaN(byteOffset)) { 21043 // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer 21044 byteOffset = dir ? 0 : (buffer.length - 1) 21045 } 21046 21047 // Normalize byteOffset: negative offsets start from the end of the buffer 21048 if (byteOffset < 0) byteOffset = buffer.length + byteOffset 21049 if (byteOffset >= buffer.length) { 21050 if (dir) return -1 21051 else byteOffset = buffer.length - 1 21052 } else if (byteOffset < 0) { 21053 if (dir) byteOffset = 0 21054 else return -1 21055 } 21056 21057 // Normalize val 21058 if (typeof val === 'string') { 21059 val = Buffer.from(val, encoding) 21060 } 21061 21062 // Finally, search either indexOf (if dir is true) or lastIndexOf 21063 if (Buffer.isBuffer(val)) { 21064 // Special case: looking for empty string/buffer always fails 21065 if (val.length === 0) { 21066 return -1 21067 } 21068 return arrayIndexOf(buffer, val, byteOffset, encoding, dir) 21069 } else if (typeof val === 'number') { 21070 val = val & 0xFF // Search for a byte value [0-255] 21071 if (Buffer.TYPED_ARRAY_SUPPORT && 21072 typeof Uint8Array.prototype.indexOf === 'function') { 21073 if (dir) { 21074 return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) 21075 } else { 21076 return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) 21077 } 21078 } 21079 return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) 21080 } 21081 21082 throw new TypeError('val must be string, number or Buffer') 21083} 21084 21085function arrayIndexOf (arr, val, byteOffset, encoding, dir) { 21086 var indexSize = 1 21087 var arrLength = arr.length 21088 var valLength = val.length 21089 21090 if (encoding !== undefined) { 21091 encoding = String(encoding).toLowerCase() 21092 if (encoding === 'ucs2' || encoding === 'ucs-2' || 21093 encoding === 'utf16le' || encoding === 'utf-16le') { 21094 if (arr.length < 2 || val.length < 2) { 21095 return -1 21096 } 21097 indexSize = 2 21098 arrLength /= 2 21099 valLength /= 2 21100 byteOffset /= 2 21101 } 21102 } 21103 21104 function read (buf, i) { 21105 if (indexSize === 1) { 21106 return buf[i] 21107 } else { 21108 return buf.readUInt16BE(i * indexSize) 21109 } 21110 } 21111 21112 var i 21113 if (dir) { 21114 var foundIndex = -1 21115 for (i = byteOffset; i < arrLength; i++) { 21116 if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { 21117 if (foundIndex === -1) foundIndex = i 21118 if (i - foundIndex + 1 === valLength) return foundIndex * indexSize 21119 } else { 21120 if (foundIndex !== -1) i -= i - foundIndex 21121 foundIndex = -1 21122 } 21123 } 21124 } else { 21125 if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength 21126 for (i = byteOffset; i >= 0; i--) { 21127 var found = true 21128 for (var j = 0; j < valLength; j++) { 21129 if (read(arr, i + j) !== read(val, j)) { 21130 found = false 21131 break 21132 } 21133 } 21134 if (found) return i 21135 } 21136 } 21137 21138 return -1 21139} 21140 21141Buffer.prototype.includes = function includes (val, byteOffset, encoding) { 21142 return this.indexOf(val, byteOffset, encoding) !== -1 21143} 21144 21145Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { 21146 return bidirectionalIndexOf(this, val, byteOffset, encoding, true) 21147} 21148 21149Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { 21150 return bidirectionalIndexOf(this, val, byteOffset, encoding, false) 21151} 21152 21153function hexWrite (buf, string, offset, length) { 21154 offset = Number(offset) || 0 21155 var remaining = buf.length - offset 21156 if (!length) { 21157 length = remaining 21158 } else { 21159 length = Number(length) 21160 if (length > remaining) { 21161 length = remaining 21162 } 21163 } 21164 21165 // must be an even number of digits 21166 var strLen = string.length 21167 if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') 21168 21169 if (length > strLen / 2) { 21170 length = strLen / 2 21171 } 21172 for (var i = 0; i < length; ++i) { 21173 var parsed = parseInt(string.substr(i * 2, 2), 16) 21174 if (isNaN(parsed)) return i 21175 buf[offset + i] = parsed 21176 } 21177 return i 21178} 21179 21180function utf8Write (buf, string, offset, length) { 21181 return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) 21182} 21183 21184function asciiWrite (buf, string, offset, length) { 21185 return blitBuffer(asciiToBytes(string), buf, offset, length) 21186} 21187 21188function latin1Write (buf, string, offset, length) { 21189 return asciiWrite(buf, string, offset, length) 21190} 21191 21192function base64Write (buf, string, offset, length) { 21193 return blitBuffer(base64ToBytes(string), buf, offset, length) 21194} 21195 21196function ucs2Write (buf, string, offset, length) { 21197 return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) 21198} 21199 21200Buffer.prototype.write = function write (string, offset, length, encoding) { 21201 // Buffer#write(string) 21202 if (offset === undefined) { 21203 encoding = 'utf8' 21204 length = this.length 21205 offset = 0 21206 // Buffer#write(string, encoding) 21207 } else if (length === undefined && typeof offset === 'string') { 21208 encoding = offset 21209 length = this.length 21210 offset = 0 21211 // Buffer#write(string, offset[, length][, encoding]) 21212 } else if (isFinite(offset)) { 21213 offset = offset | 0 21214 if (isFinite(length)) { 21215 length = length | 0 21216 if (encoding === undefined) encoding = 'utf8' 21217 } else { 21218 encoding = length 21219 length = undefined 21220 } 21221 // legacy write(string, encoding, offset, length) - remove in v0.13 21222 } else { 21223 throw new Error( 21224 'Buffer.write(string, encoding, offset[, length]) is no longer supported' 21225 ) 21226 } 21227 21228 var remaining = this.length - offset 21229 if (length === undefined || length > remaining) length = remaining 21230 21231 if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { 21232 throw new RangeError('Attempt to write outside buffer bounds') 21233 } 21234 21235 if (!encoding) encoding = 'utf8' 21236 21237 var loweredCase = false 21238 for (;;) { 21239 switch (encoding) { 21240 case 'hex': 21241 return hexWrite(this, string, offset, length) 21242 21243 case 'utf8': 21244 case 'utf-8': 21245 return utf8Write(this, string, offset, length) 21246 21247 case 'ascii': 21248 return asciiWrite(this, string, offset, length) 21249 21250 case 'latin1': 21251 case 'binary': 21252 return latin1Write(this, string, offset, length) 21253 21254 case 'base64': 21255 // Warning: maxLength not taken into account in base64Write 21256 return base64Write(this, string, offset, length) 21257 21258 case 'ucs2': 21259 case 'ucs-2': 21260 case 'utf16le': 21261 case 'utf-16le': 21262 return ucs2Write(this, string, offset, length) 21263 21264 default: 21265 if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) 21266 encoding = ('' + encoding).toLowerCase() 21267 loweredCase = true 21268 } 21269 } 21270} 21271 21272Buffer.prototype.toJSON = function toJSON () { 21273 return { 21274 type: 'Buffer', 21275 data: Array.prototype.slice.call(this._arr || this, 0) 21276 } 21277} 21278 21279function base64Slice (buf, start, end) { 21280 if (start === 0 && end === buf.length) { 21281 return base64.fromByteArray(buf) 21282 } else { 21283 return base64.fromByteArray(buf.slice(start, end)) 21284 } 21285} 21286 21287function utf8Slice (buf, start, end) { 21288 end = Math.min(buf.length, end) 21289 var res = [] 21290 21291 var i = start 21292 while (i < end) { 21293 var firstByte = buf[i] 21294 var codePoint = null 21295 var bytesPerSequence = (firstByte > 0xEF) ? 4 21296 : (firstByte > 0xDF) ? 3 21297 : (firstByte > 0xBF) ? 2 21298 : 1 21299 21300 if (i + bytesPerSequence <= end) { 21301 var secondByte, thirdByte, fourthByte, tempCodePoint 21302 21303 switch (bytesPerSequence) { 21304 case 1: 21305 if (firstByte < 0x80) { 21306 codePoint = firstByte 21307 } 21308 break 21309 case 2: 21310 secondByte = buf[i + 1] 21311 if ((secondByte & 0xC0) === 0x80) { 21312 tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) 21313 if (tempCodePoint > 0x7F) { 21314 codePoint = tempCodePoint 21315 } 21316 } 21317 break 21318 case 3: 21319 secondByte = buf[i + 1] 21320 thirdByte = buf[i + 2] 21321 if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { 21322 tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) 21323 if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { 21324 codePoint = tempCodePoint 21325 } 21326 } 21327 break 21328 case 4: 21329 secondByte = buf[i + 1] 21330 thirdByte = buf[i + 2] 21331 fourthByte = buf[i + 3] 21332 if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { 21333 tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) 21334 if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { 21335 codePoint = tempCodePoint 21336 } 21337 } 21338 } 21339 } 21340 21341 if (codePoint === null) { 21342 // we did not generate a valid codePoint so insert a 21343 // replacement char (U+FFFD) and advance only 1 byte 21344 codePoint = 0xFFFD 21345 bytesPerSequence = 1 21346 } else if (codePoint > 0xFFFF) { 21347 // encode to utf16 (surrogate pair dance) 21348 codePoint -= 0x10000 21349 res.push(codePoint >>> 10 & 0x3FF | 0xD800) 21350 codePoint = 0xDC00 | codePoint & 0x3FF 21351 } 21352 21353 res.push(codePoint) 21354 i += bytesPerSequence 21355 } 21356 21357 return decodeCodePointsArray(res) 21358} 21359 21360// Based on http://stackoverflow.com/a/22747272/680742, the browser with 21361// the lowest limit is Chrome, with 0x10000 args. 21362// We go 1 magnitude less, for safety 21363var MAX_ARGUMENTS_LENGTH = 0x1000 21364 21365function decodeCodePointsArray (codePoints) { 21366 var len = codePoints.length 21367 if (len <= MAX_ARGUMENTS_LENGTH) { 21368 return String.fromCharCode.apply(String, codePoints) // avoid extra slice() 21369 } 21370 21371 // Decode in chunks to avoid "call stack size exceeded". 21372 var res = '' 21373 var i = 0 21374 while (i < len) { 21375 res += String.fromCharCode.apply( 21376 String, 21377 codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) 21378 ) 21379 } 21380 return res 21381} 21382 21383function asciiSlice (buf, start, end) { 21384 var ret = '' 21385 end = Math.min(buf.length, end) 21386 21387 for (var i = start; i < end; ++i) { 21388 ret += String.fromCharCode(buf[i] & 0x7F) 21389 } 21390 return ret 21391} 21392 21393function latin1Slice (buf, start, end) { 21394 var ret = '' 21395 end = Math.min(buf.length, end) 21396 21397 for (var i = start; i < end; ++i) { 21398 ret += String.fromCharCode(buf[i]) 21399 } 21400 return ret 21401} 21402 21403function hexSlice (buf, start, end) { 21404 var len = buf.length 21405 21406 if (!start || start < 0) start = 0 21407 if (!end || end < 0 || end > len) end = len 21408 21409 var out = '' 21410 for (var i = start; i < end; ++i) { 21411 out += toHex(buf[i]) 21412 } 21413 return out 21414} 21415 21416function utf16leSlice (buf, start, end) { 21417 var bytes = buf.slice(start, end) 21418 var res = '' 21419 for (var i = 0; i < bytes.length; i += 2) { 21420 res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) 21421 } 21422 return res 21423} 21424 21425Buffer.prototype.slice = function slice (start, end) { 21426 var len = this.length 21427 start = ~~start 21428 end = end === undefined ? len : ~~end 21429 21430 if (start < 0) { 21431 start += len 21432 if (start < 0) start = 0 21433 } else if (start > len) { 21434 start = len 21435 } 21436 21437 if (end < 0) { 21438 end += len 21439 if (end < 0) end = 0 21440 } else if (end > len) { 21441 end = len 21442 } 21443 21444 if (end < start) end = start 21445 21446 var newBuf 21447 if (Buffer.TYPED_ARRAY_SUPPORT) { 21448 newBuf = this.subarray(start, end) 21449 newBuf.__proto__ = Buffer.prototype 21450 } else { 21451 var sliceLen = end - start 21452 newBuf = new Buffer(sliceLen, undefined) 21453 for (var i = 0; i < sliceLen; ++i) { 21454 newBuf[i] = this[i + start] 21455 } 21456 } 21457 21458 return newBuf 21459} 21460 21461/* 21462 * Need to make sure that buffer isn't trying to write out of bounds. 21463 */ 21464function checkOffset (offset, ext, length) { 21465 if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') 21466 if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') 21467} 21468 21469Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { 21470 offset = offset | 0 21471 byteLength = byteLength | 0 21472 if (!noAssert) checkOffset(offset, byteLength, this.length) 21473 21474 var val = this[offset] 21475 var mul = 1 21476 var i = 0 21477 while (++i < byteLength && (mul *= 0x100)) { 21478 val += this[offset + i] * mul 21479 } 21480 21481 return val 21482} 21483 21484Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { 21485 offset = offset | 0 21486 byteLength = byteLength | 0 21487 if (!noAssert) { 21488 checkOffset(offset, byteLength, this.length) 21489 } 21490 21491 var val = this[offset + --byteLength] 21492 var mul = 1 21493 while (byteLength > 0 && (mul *= 0x100)) { 21494 val += this[offset + --byteLength] * mul 21495 } 21496 21497 return val 21498} 21499 21500Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { 21501 if (!noAssert) checkOffset(offset, 1, this.length) 21502 return this[offset] 21503} 21504 21505Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { 21506 if (!noAssert) checkOffset(offset, 2, this.length) 21507 return this[offset] | (this[offset + 1] << 8) 21508} 21509 21510Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { 21511 if (!noAssert) checkOffset(offset, 2, this.length) 21512 return (this[offset] << 8) | this[offset + 1] 21513} 21514 21515Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { 21516 if (!noAssert) checkOffset(offset, 4, this.length) 21517 21518 return ((this[offset]) | 21519 (this[offset + 1] << 8) | 21520 (this[offset + 2] << 16)) + 21521 (this[offset + 3] * 0x1000000) 21522} 21523 21524Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { 21525 if (!noAssert) checkOffset(offset, 4, this.length) 21526 21527 return (this[offset] * 0x1000000) + 21528 ((this[offset + 1] << 16) | 21529 (this[offset + 2] << 8) | 21530 this[offset + 3]) 21531} 21532 21533Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { 21534 offset = offset | 0 21535 byteLength = byteLength | 0 21536 if (!noAssert) checkOffset(offset, byteLength, this.length) 21537 21538 var val = this[offset] 21539 var mul = 1 21540 var i = 0 21541 while (++i < byteLength && (mul *= 0x100)) { 21542 val += this[offset + i] * mul 21543 } 21544 mul *= 0x80 21545 21546 if (val >= mul) val -= Math.pow(2, 8 * byteLength) 21547 21548 return val 21549} 21550 21551Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { 21552 offset = offset | 0 21553 byteLength = byteLength | 0 21554 if (!noAssert) checkOffset(offset, byteLength, this.length) 21555 21556 var i = byteLength 21557 var mul = 1 21558 var val = this[offset + --i] 21559 while (i > 0 && (mul *= 0x100)) { 21560 val += this[offset + --i] * mul 21561 } 21562 mul *= 0x80 21563 21564 if (val >= mul) val -= Math.pow(2, 8 * byteLength) 21565 21566 return val 21567} 21568 21569Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { 21570 if (!noAssert) checkOffset(offset, 1, this.length) 21571 if (!(this[offset] & 0x80)) return (this[offset]) 21572 return ((0xff - this[offset] + 1) * -1) 21573} 21574 21575Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { 21576 if (!noAssert) checkOffset(offset, 2, this.length) 21577 var val = this[offset] | (this[offset + 1] << 8) 21578 return (val & 0x8000) ? val | 0xFFFF0000 : val 21579} 21580 21581Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { 21582 if (!noAssert) checkOffset(offset, 2, this.length) 21583 var val = this[offset + 1] | (this[offset] << 8) 21584 return (val & 0x8000) ? val | 0xFFFF0000 : val 21585} 21586 21587Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { 21588 if (!noAssert) checkOffset(offset, 4, this.length) 21589 21590 return (this[offset]) | 21591 (this[offset + 1] << 8) | 21592 (this[offset + 2] << 16) | 21593 (this[offset + 3] << 24) 21594} 21595 21596Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { 21597 if (!noAssert) checkOffset(offset, 4, this.length) 21598 21599 return (this[offset] << 24) | 21600 (this[offset + 1] << 16) | 21601 (this[offset + 2] << 8) | 21602 (this[offset + 3]) 21603} 21604 21605Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { 21606 if (!noAssert) checkOffset(offset, 4, this.length) 21607 return ieee754.read(this, offset, true, 23, 4) 21608} 21609 21610Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { 21611 if (!noAssert) checkOffset(offset, 4, this.length) 21612 return ieee754.read(this, offset, false, 23, 4) 21613} 21614 21615Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { 21616 if (!noAssert) checkOffset(offset, 8, this.length) 21617 return ieee754.read(this, offset, true, 52, 8) 21618} 21619 21620Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { 21621 if (!noAssert) checkOffset(offset, 8, this.length) 21622 return ieee754.read(this, offset, false, 52, 8) 21623} 21624 21625function checkInt (buf, value, offset, ext, max, min) { 21626 if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') 21627 if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') 21628 if (offset + ext > buf.length) throw new RangeError('Index out of range') 21629} 21630 21631Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { 21632 value = +value 21633 offset = offset | 0 21634 byteLength = byteLength | 0 21635 if (!noAssert) { 21636 var maxBytes = Math.pow(2, 8 * byteLength) - 1 21637 checkInt(this, value, offset, byteLength, maxBytes, 0) 21638 } 21639 21640 var mul = 1 21641 var i = 0 21642 this[offset] = value & 0xFF 21643 while (++i < byteLength && (mul *= 0x100)) { 21644 this[offset + i] = (value / mul) & 0xFF 21645 } 21646 21647 return offset + byteLength 21648} 21649 21650Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { 21651 value = +value 21652 offset = offset | 0 21653 byteLength = byteLength | 0 21654 if (!noAssert) { 21655 var maxBytes = Math.pow(2, 8 * byteLength) - 1 21656 checkInt(this, value, offset, byteLength, maxBytes, 0) 21657 } 21658 21659 var i = byteLength - 1 21660 var mul = 1 21661 this[offset + i] = value & 0xFF 21662 while (--i >= 0 && (mul *= 0x100)) { 21663 this[offset + i] = (value / mul) & 0xFF 21664 } 21665 21666 return offset + byteLength 21667} 21668 21669Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { 21670 value = +value 21671 offset = offset | 0 21672 if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) 21673 if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) 21674 this[offset] = (value & 0xff) 21675 return offset + 1 21676} 21677 21678function objectWriteUInt16 (buf, value, offset, littleEndian) { 21679 if (value < 0) value = 0xffff + value + 1 21680 for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { 21681 buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> 21682 (littleEndian ? i : 1 - i) * 8 21683 } 21684} 21685 21686Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { 21687 value = +value 21688 offset = offset | 0 21689 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) 21690 if (Buffer.TYPED_ARRAY_SUPPORT) { 21691 this[offset] = (value & 0xff) 21692 this[offset + 1] = (value >>> 8) 21693 } else { 21694 objectWriteUInt16(this, value, offset, true) 21695 } 21696 return offset + 2 21697} 21698 21699Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { 21700 value = +value 21701 offset = offset | 0 21702 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) 21703 if (Buffer.TYPED_ARRAY_SUPPORT) { 21704 this[offset] = (value >>> 8) 21705 this[offset + 1] = (value & 0xff) 21706 } else { 21707 objectWriteUInt16(this, value, offset, false) 21708 } 21709 return offset + 2 21710} 21711 21712function objectWriteUInt32 (buf, value, offset, littleEndian) { 21713 if (value < 0) value = 0xffffffff + value + 1 21714 for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { 21715 buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff 21716 } 21717} 21718 21719Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { 21720 value = +value 21721 offset = offset | 0 21722 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) 21723 if (Buffer.TYPED_ARRAY_SUPPORT) { 21724 this[offset + 3] = (value >>> 24) 21725 this[offset + 2] = (value >>> 16) 21726 this[offset + 1] = (value >>> 8) 21727 this[offset] = (value & 0xff) 21728 } else { 21729 objectWriteUInt32(this, value, offset, true) 21730 } 21731 return offset + 4 21732} 21733 21734Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { 21735 value = +value 21736 offset = offset | 0 21737 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) 21738 if (Buffer.TYPED_ARRAY_SUPPORT) { 21739 this[offset] = (value >>> 24) 21740 this[offset + 1] = (value >>> 16) 21741 this[offset + 2] = (value >>> 8) 21742 this[offset + 3] = (value & 0xff) 21743 } else { 21744 objectWriteUInt32(this, value, offset, false) 21745 } 21746 return offset + 4 21747} 21748 21749Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { 21750 value = +value 21751 offset = offset | 0 21752 if (!noAssert) { 21753 var limit = Math.pow(2, 8 * byteLength - 1) 21754 21755 checkInt(this, value, offset, byteLength, limit - 1, -limit) 21756 } 21757 21758 var i = 0 21759 var mul = 1 21760 var sub = 0 21761 this[offset] = value & 0xFF 21762 while (++i < byteLength && (mul *= 0x100)) { 21763 if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { 21764 sub = 1 21765 } 21766 this[offset + i] = ((value / mul) >> 0) - sub & 0xFF 21767 } 21768 21769 return offset + byteLength 21770} 21771 21772Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { 21773 value = +value 21774 offset = offset | 0 21775 if (!noAssert) { 21776 var limit = Math.pow(2, 8 * byteLength - 1) 21777 21778 checkInt(this, value, offset, byteLength, limit - 1, -limit) 21779 } 21780 21781 var i = byteLength - 1 21782 var mul = 1 21783 var sub = 0 21784 this[offset + i] = value & 0xFF 21785 while (--i >= 0 && (mul *= 0x100)) { 21786 if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { 21787 sub = 1 21788 } 21789 this[offset + i] = ((value / mul) >> 0) - sub & 0xFF 21790 } 21791 21792 return offset + byteLength 21793} 21794 21795Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { 21796 value = +value 21797 offset = offset | 0 21798 if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) 21799 if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) 21800 if (value < 0) value = 0xff + value + 1 21801 this[offset] = (value & 0xff) 21802 return offset + 1 21803} 21804 21805Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { 21806 value = +value 21807 offset = offset | 0 21808 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) 21809 if (Buffer.TYPED_ARRAY_SUPPORT) { 21810 this[offset] = (value & 0xff) 21811 this[offset + 1] = (value >>> 8) 21812 } else { 21813 objectWriteUInt16(this, value, offset, true) 21814 } 21815 return offset + 2 21816} 21817 21818Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { 21819 value = +value 21820 offset = offset | 0 21821 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) 21822 if (Buffer.TYPED_ARRAY_SUPPORT) { 21823 this[offset] = (value >>> 8) 21824 this[offset + 1] = (value & 0xff) 21825 } else { 21826 objectWriteUInt16(this, value, offset, false) 21827 } 21828 return offset + 2 21829} 21830 21831Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { 21832 value = +value 21833 offset = offset | 0 21834 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) 21835 if (Buffer.TYPED_ARRAY_SUPPORT) { 21836 this[offset] = (value & 0xff) 21837 this[offset + 1] = (value >>> 8) 21838 this[offset + 2] = (value >>> 16) 21839 this[offset + 3] = (value >>> 24) 21840 } else { 21841 objectWriteUInt32(this, value, offset, true) 21842 } 21843 return offset + 4 21844} 21845 21846Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { 21847 value = +value 21848 offset = offset | 0 21849 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) 21850 if (value < 0) value = 0xffffffff + value + 1 21851 if (Buffer.TYPED_ARRAY_SUPPORT) { 21852 this[offset] = (value >>> 24) 21853 this[offset + 1] = (value >>> 16) 21854 this[offset + 2] = (value >>> 8) 21855 this[offset + 3] = (value & 0xff) 21856 } else { 21857 objectWriteUInt32(this, value, offset, false) 21858 } 21859 return offset + 4 21860} 21861 21862function checkIEEE754 (buf, value, offset, ext, max, min) { 21863 if (offset + ext > buf.length) throw new RangeError('Index out of range') 21864 if (offset < 0) throw new RangeError('Index out of range') 21865} 21866 21867function writeFloat (buf, value, offset, littleEndian, noAssert) { 21868 if (!noAssert) { 21869 checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) 21870 } 21871 ieee754.write(buf, value, offset, littleEndian, 23, 4) 21872 return offset + 4 21873} 21874 21875Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { 21876 return writeFloat(this, value, offset, true, noAssert) 21877} 21878 21879Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { 21880 return writeFloat(this, value, offset, false, noAssert) 21881} 21882 21883function writeDouble (buf, value, offset, littleEndian, noAssert) { 21884 if (!noAssert) { 21885 checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) 21886 } 21887 ieee754.write(buf, value, offset, littleEndian, 52, 8) 21888 return offset + 8 21889} 21890 21891Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { 21892 return writeDouble(this, value, offset, true, noAssert) 21893} 21894 21895Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { 21896 return writeDouble(this, value, offset, false, noAssert) 21897} 21898 21899// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) 21900Buffer.prototype.copy = function copy (target, targetStart, start, end) { 21901 if (!start) start = 0 21902 if (!end && end !== 0) end = this.length 21903 if (targetStart >= target.length) targetStart = target.length 21904 if (!targetStart) targetStart = 0 21905 if (end > 0 && end < start) end = start 21906 21907 // Copy 0 bytes; we're done 21908 if (end === start) return 0 21909 if (target.length === 0 || this.length === 0) return 0 21910 21911 // Fatal error conditions 21912 if (targetStart < 0) { 21913 throw new RangeError('targetStart out of bounds') 21914 } 21915 if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') 21916 if (end < 0) throw new RangeError('sourceEnd out of bounds') 21917 21918 // Are we oob? 21919 if (end > this.length) end = this.length 21920 if (target.length - targetStart < end - start) { 21921 end = target.length - targetStart + start 21922 } 21923 21924 var len = end - start 21925 var i 21926 21927 if (this === target && start < targetStart && targetStart < end) { 21928 // descending copy from end 21929 for (i = len - 1; i >= 0; --i) { 21930 target[i + targetStart] = this[i + start] 21931 } 21932 } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { 21933 // ascending copy from start 21934 for (i = 0; i < len; ++i) { 21935 target[i + targetStart] = this[i + start] 21936 } 21937 } else { 21938 Uint8Array.prototype.set.call( 21939 target, 21940 this.subarray(start, start + len), 21941 targetStart 21942 ) 21943 } 21944 21945 return len 21946} 21947 21948// Usage: 21949// buffer.fill(number[, offset[, end]]) 21950// buffer.fill(buffer[, offset[, end]]) 21951// buffer.fill(string[, offset[, end]][, encoding]) 21952Buffer.prototype.fill = function fill (val, start, end, encoding) { 21953 // Handle string cases: 21954 if (typeof val === 'string') { 21955 if (typeof start === 'string') { 21956 encoding = start 21957 start = 0 21958 end = this.length 21959 } else if (typeof end === 'string') { 21960 encoding = end 21961 end = this.length 21962 } 21963 if (val.length === 1) { 21964 var code = val.charCodeAt(0) 21965 if (code < 256) { 21966 val = code 21967 } 21968 } 21969 if (encoding !== undefined && typeof encoding !== 'string') { 21970 throw new TypeError('encoding must be a string') 21971 } 21972 if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { 21973 throw new TypeError('Unknown encoding: ' + encoding) 21974 } 21975 } else if (typeof val === 'number') { 21976 val = val & 255 21977 } 21978 21979 // Invalid ranges are not set to a default, so can range check early. 21980 if (start < 0 || this.length < start || this.length < end) { 21981 throw new RangeError('Out of range index') 21982 } 21983 21984 if (end <= start) { 21985 return this 21986 } 21987 21988 start = start >>> 0 21989 end = end === undefined ? this.length : end >>> 0 21990 21991 if (!val) val = 0 21992 21993 var i 21994 if (typeof val === 'number') { 21995 for (i = start; i < end; ++i) { 21996 this[i] = val 21997 } 21998 } else { 21999 var bytes = Buffer.isBuffer(val) 22000 ? val 22001 : utf8ToBytes(new Buffer(val, encoding).toString()) 22002 var len = bytes.length 22003 for (i = 0; i < end - start; ++i) { 22004 this[i + start] = bytes[i % len] 22005 } 22006 } 22007 22008 return this 22009} 22010 22011// HELPER FUNCTIONS 22012// ================ 22013 22014var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g 22015 22016function base64clean (str) { 22017 // Node strips out invalid characters like \n and \t from the string, base64-js does not 22018 str = stringtrim(str).replace(INVALID_BASE64_RE, '') 22019 // Node converts strings with length < 2 to '' 22020 if (str.length < 2) return '' 22021 // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not 22022 while (str.length % 4 !== 0) { 22023 str = str + '=' 22024 } 22025 return str 22026} 22027 22028function stringtrim (str) { 22029 if (str.trim) return str.trim() 22030 return str.replace(/^\s+|\s+$/g, '') 22031} 22032 22033function toHex (n) { 22034 if (n < 16) return '0' + n.toString(16) 22035 return n.toString(16) 22036} 22037 22038function utf8ToBytes (string, units) { 22039 units = units || Infinity 22040 var codePoint 22041 var length = string.length 22042 var leadSurrogate = null 22043 var bytes = [] 22044 22045 for (var i = 0; i < length; ++i) { 22046 codePoint = string.charCodeAt(i) 22047 22048 // is surrogate component 22049 if (codePoint > 0xD7FF && codePoint < 0xE000) { 22050 // last char was a lead 22051 if (!leadSurrogate) { 22052 // no lead yet 22053 if (codePoint > 0xDBFF) { 22054 // unexpected trail 22055 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 22056 continue 22057 } else if (i + 1 === length) { 22058 // unpaired lead 22059 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 22060 continue 22061 } 22062 22063 // valid lead 22064 leadSurrogate = codePoint 22065 22066 continue 22067 } 22068 22069 // 2 leads in a row 22070 if (codePoint < 0xDC00) { 22071 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 22072 leadSurrogate = codePoint 22073 continue 22074 } 22075 22076 // valid surrogate pair 22077 codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 22078 } else if (leadSurrogate) { 22079 // valid bmp char, but last char was a lead 22080 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 22081 } 22082 22083 leadSurrogate = null 22084 22085 // encode utf8 22086 if (codePoint < 0x80) { 22087 if ((units -= 1) < 0) break 22088 bytes.push(codePoint) 22089 } else if (codePoint < 0x800) { 22090 if ((units -= 2) < 0) break 22091 bytes.push( 22092 codePoint >> 0x6 | 0xC0, 22093 codePoint & 0x3F | 0x80 22094 ) 22095 } else if (codePoint < 0x10000) { 22096 if ((units -= 3) < 0) break 22097 bytes.push( 22098 codePoint >> 0xC | 0xE0, 22099 codePoint >> 0x6 & 0x3F | 0x80, 22100 codePoint & 0x3F | 0x80 22101 ) 22102 } else if (codePoint < 0x110000) { 22103 if ((units -= 4) < 0) break 22104 bytes.push( 22105 codePoint >> 0x12 | 0xF0, 22106 codePoint >> 0xC & 0x3F | 0x80, 22107 codePoint >> 0x6 & 0x3F | 0x80, 22108 codePoint & 0x3F | 0x80 22109 ) 22110 } else { 22111 throw new Error('Invalid code point') 22112 } 22113 } 22114 22115 return bytes 22116} 22117 22118function asciiToBytes (str) { 22119 var byteArray = [] 22120 for (var i = 0; i < str.length; ++i) { 22121 // Node's code seems to be doing this and not & 0x7F.. 22122 byteArray.push(str.charCodeAt(i) & 0xFF) 22123 } 22124 return byteArray 22125} 22126 22127function utf16leToBytes (str, units) { 22128 var c, hi, lo 22129 var byteArray = [] 22130 for (var i = 0; i < str.length; ++i) { 22131 if ((units -= 2) < 0) break 22132 22133 c = str.charCodeAt(i) 22134 hi = c >> 8 22135 lo = c % 256 22136 byteArray.push(lo) 22137 byteArray.push(hi) 22138 } 22139 22140 return byteArray 22141} 22142 22143function base64ToBytes (str) { 22144 return base64.toByteArray(base64clean(str)) 22145} 22146 22147function blitBuffer (src, dst, offset, length) { 22148 for (var i = 0; i < length; ++i) { 22149 if ((i + offset >= dst.length) || (i >= src.length)) break 22150 dst[i + offset] = src[i] 22151 } 22152 return i 22153} 22154 22155function isnan (val) { 22156 return val !== val // eslint-disable-line no-self-compare 22157} 22158 22159 22160/***/ }), 22161
vendor: 1,872 bytes, lines 22162-22237
22162/***/ "./node_modules/css-loader/dist/runtime/api.js": 22163/*!*****************************************************!*\ 22164 !*** ./node_modules/css-loader/dist/runtime/api.js ***! 22165 \*****************************************************/ 22166/***/ ((module) => { 22167 22168"use strict"; 22169 22170 22171/* 22172 MIT License http://www.opensource.org/licenses/mit-license.php 22173 Author Tobias Koppers @sokra 22174*/ 22175// css base code, injected by the css-loader 22176// eslint-disable-next-line func-names 22177module.exports = function (cssWithMappingToString) { 22178 var list = []; // return the list of modules as css string 22179 22180 list.toString = function toString() { 22181 return this.map(function (item) { 22182 var content = cssWithMappingToString(item); 22183 22184 if (item[2]) { 22185 return "@media ".concat(item[2], " {").concat(content, "}"); 22186 } 22187 22188 return content; 22189 }).join(""); 22190 }; // import a list of modules into the list 22191 // eslint-disable-next-line func-names 22192 22193 22194 list.i = function (modules, mediaQuery, dedupe) { 22195 if (typeof modules === "string") { 22196 // eslint-disable-next-line no-param-reassign 22197 modules = [[null, modules, ""]]; 22198 } 22199 22200 var alreadyImportedModules = {}; 22201 22202 if (dedupe) { 22203 for (var i = 0; i < this.length; i++) { 22204 // eslint-disable-next-line prefer-destructuring 22205 var id = this[i][0]; 22206 22207 if (id != null) { 22208 alreadyImportedModules[id] = true; 22209 } 22210 } 22211 } 22212 22213 for (var _i = 0; _i < modules.length; _i++) { 22214 var item = [].concat(modules[_i]); 22215 22216 if (dedupe && alreadyImportedModules[item[0]]) { 22217 // eslint-disable-next-line no-continue 22218 continue; 22219 } 22220 22221 if (mediaQuery) { 22222 if (!item[2]) { 22223 item[2] = mediaQuery; 22224 } else { 22225 item[2] = "".concat(mediaQuery, " and ").concat(item[2]); 22226 } 22227 } 22228 22229 list.push(item); 22230 } 22231 }; 22232 22233 return list; 22234}; 22235 22236/***/ }), 22237
vendor: 7,226 bytes, lines 22238-22247
22238/***/ "./node_modules/dayjs/dayjs.min.js": 22239/*!*****************************************!*\ 22240 !*** ./node_modules/dayjs/dayjs.min.js ***! 22241 \*****************************************/ 22242/***/ (function(module) { 22243 22244!function(t,e){ true?module.exports=e():0}(this,(function(){"use strict";var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",c="month",f="quarter",h="year",d="date",l="Invalid Date",$=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function(t){var e=["th","st","nd","rd"],n=t%100;return"["+t+(e[(n-20)%10]||e[n]||e[0])+"]"}},m=function(t,e,n){var r=String(t);return!r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()<n.date())return-t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,c),s=n-i<0,u=e.clone().add(r+(s?-1:1),c);return+(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return{M:c,y:h,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:f}[t]||String(t||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},g="en",D={};D[g]=M;var p="$isDayjsObject",S=function(t){return t instanceof _||!(!t||!t[p])},w=function t(e,n,r){var i;if(!e)return g;if("string"==typeof e){var s=e.toLowerCase();D[s]&&(i=s),n&&(D[s]=n,i=s);var u=e.split("-");if(!i&&u.length>1)return t(u[0])}else{var a=e.name;D[a]=e,i=a}return!r&&i&&(g=i),i||!r&&g},O=function(t,e){if(S(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},b=v;b.l=w,b.i=S,b.w=function(t,e){return O(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=w(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[p]=!0}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(b.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.init()},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},m.$utils=function(){return b},m.isValid=function(){return!(this.$d.toString()===l)},m.isSame=function(t,e){var n=O(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return O(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<O(t)},m.$g=function(t,e,n){return b.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!b.u(e)||e,f=b.p(t),l=function(t,e){var i=b.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},$=function(t,e){return b.w(n.toDate()[t].apply(n.toDate("s"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,v="set"+(this.$u?"UTC":"");switch(f){case h:return r?l(1,0):l(31,11);case c:return r?l(1,M):l(0,M+1);case o:var g=this.$locale().weekStart||0,D=(y<g?y+7:y)-g;return l(r?m-D:m+(6-D),M);case a:case d:return $(v+"Hours",0);case u:return $(v+"Minutes",1);case s:return $(v+"Seconds",2);case i:return $(v+"Milliseconds",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=b.p(t),f="set"+(this.$u?"UTC":""),l=(n={},n[a]=f+"Date",n[d]=f+"Date",n[c]=f+"Month",n[h]=f+"FullYear",n[u]=f+"Hours",n[s]=f+"Minutes",n[i]=f+"Seconds",n[r]=f+"Milliseconds",n)[o],$=o===a?this.$D+(e-this.$W):e;if(o===c||o===h){var y=this.clone().set(d,1);y.$d[l]($),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d}else l&&this.$d[l]($);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[b.p(t)]()},m.add=function(r,f){var d,l=this;r=Number(r);var $=b.p(f),y=function(t){var e=O(l);return b.w(e.date(e.date()+Math.round(t*r)),l)};if($===c)return this.set(c,this.$M+r);if($===h)return this.set(h,this.$y+r);if($===a)return y(1);if($===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[$]||1,m=this.$d.getTime()+r*M;return b.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||l;var r=t||"YYYY-MM-DDTHH:mm:ssZ",i=b.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,c=n.months,f=n.meridiem,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].slice(0,s)},d=function(t){return b.s(s%12||12,t,"0")},$=f||function(t,e,n){var r=t<12?"AM":"PM";return n?r.toLowerCase():r};return r.replace(y,(function(t,r){return r||function(t){switch(t){case"YY":return String(e.$y).slice(-2);case"YYYY":return b.s(e.$y,4,"0");case"M":return a+1;case"MM":return b.s(a+1,2,"0");case"MMM":return h(n.monthsShort,a,c,3);case"MMMM":return h(c,a);case"D":return e.$D;case"DD":return b.s(e.$D,2,"0");case"d":return String(e.$W);case"dd":return h(n.weekdaysMin,e.$W,o,2);case"ddd":return h(n.weekdaysShort,e.$W,o,3);case"dddd":return o[e.$W];case"H":return String(s);case"HH":return b.s(s,2,"0");case"h":return d(1);case"hh":return d(2);case"a":return $(s,u,!0);case"A":return $(s,u,!1);case"m":return String(u);case"mm":return b.s(u,2,"0");case"s":return String(e.$s);case"ss":return b.s(e.$s,2,"0");case"SSS":return b.s(e.$ms,3,"0");case"Z":return i}return null}(t)||i.replace(":","")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,l){var $,y=this,M=b.p(d),m=O(r),v=(m.utcOffset()-this.utcOffset())*e,g=this-m,D=function(){return b.m(y,m)};switch(M){case h:$=D()/12;break;case c:$=D();break;case f:$=D()/3;break;case o:$=(g-v)/6048e5;break;case a:$=(g-v)/864e5;break;case u:$=g/n;break;case s:$=g/e;break;case i:$=g/t;break;default:$=g}return l?$:b.a($)},m.daysInMonth=function(){return this.endOf(c).$D},m.$locale=function(){return D[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=w(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return b.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),k=_.prototype;return O.prototype=k,[["$ms",r],["$s",i],["$m",s],["$H",u],["$W",a],["$M",c],["$y",h],["$D",d]].forEach((function(t){k[t[1]]=function(e){return this.$g(e,t[0],t[1])}})),O.extend=function(t,e){return t.$i||(t(e,_,O),t.$i=!0),O},O.locale=w,O.isDayjs=S,O.unix=function(t){return O(1e3*t)},O.en=D[g],O.Ls=D,O.p={},O})); 22245 22246/***/ }), 22247
vendor: 1,628 bytes, lines 22248-22257
22248/***/ "./node_modules/dayjs/locale/bg.js": 22249/*!*****************************************!*\ 22250 !*** ./node_modules/dayjs/locale/bg.js ***! 22251 \*****************************************/ 22252/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 22253 22254!function(e,_){ true?module.exports=_(__webpack_require__(/*! dayjs */ "./node_modules/dayjs/dayjs.min.js")):0}(this,(function(e){"use strict";function _(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var t=_(e),d={name:"bg",weekdays:"неделÑ_понеделник_вÑоÑник_ÑÑÑда_ÑеÑвÑÑÑÑк_пеÑÑк_ÑÑбоÑа".split("_"),weekdaysShort:"нед_пон_вÑо_ÑÑÑ_ÑеÑ_пеÑ_ÑÑб".split("_"),weekdaysMin:"нд_пн_вÑ_ÑÑ_ÑÑ_пÑ_Ñб".split("_"),months:"ÑнÑаÑи_ÑевÑÑаÑи_маÑÑ_апÑил_май_Ñни_Ñли_авгÑÑÑ_ÑепÑемвÑи_окÑомвÑи_ноемвÑи_декемвÑи".split("_"),monthsShort:"ÑнÑ_Ñев_маÑ_апÑ_май_Ñни_Ñли_авг_Ñеп_окÑ_ное_дек".split("_"),weekStart:1,ordinal:function(e){var _=e%100;if(_>10&&_<20)return e+"-Ñи";var t=e%10;return 1===t?e+"-ви":2===t?e+"-Ñи":7===t||8===t?e+"-ми":e+"-Ñи"},formats:{LT:"H:mm",LTS:"H:mm:ss",L:"D.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},relativeTime:{future:"Ñлед %s",past:"пÑеди %s",s:"нÑколко ÑекÑнди",m:"минÑÑа",mm:"%d минÑÑи",h:"ÑаÑ",hh:"%d ÑаÑа",d:"ден",dd:"%d дена",M:"меÑеÑ",MM:"%d меÑеÑа",y:"година",yy:"%d години"}};return t.default.locale(d,null,!0),d})); 22255 22256/***/ }), 22257
vendor: 1,276 bytes, lines 22258-22267
22258/***/ "./node_modules/dayjs/locale/tr.js": 22259/*!*****************************************!*\ 22260 !*** ./node_modules/dayjs/locale/tr.js ***! 22261 \*****************************************/ 22262/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 22263 22264!function(a,e){ true?module.exports=e(__webpack_require__(/*! dayjs */ "./node_modules/dayjs/dayjs.min.js")):0}(this,(function(a){"use strict";function e(a){return a&&"object"==typeof a&&"default"in a?a:{default:a}}var t=e(a),_={name:"tr",weekdays:"Pazar_Pazartesi_Salı_ÃarÅamba_PerÅembe_Cuma_Cumartesi".split("_"),weekdaysShort:"Paz_Pts_Sal_Ãar_Per_Cum_Cts".split("_"),weekdaysMin:"Pz_Pt_Sa_Ãa_Pe_Cu_Ct".split("_"),months:"Ocak_Åubat_Mart_Nisan_Mayıs_Haziran_Temmuz_AÄustos_Eylül_Ekim_Kasım_Aralık".split("_"),monthsShort:"Oca_Åub_Mar_Nis_May_Haz_Tem_AÄu_Eyl_Eki_Kas_Ara".split("_"),weekStart:1,formats:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},relativeTime:{future:"%s sonra",past:"%s önce",s:"birkaç saniye",m:"bir dakika",mm:"%d dakika",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",M:"bir ay",MM:"%d ay",y:"bir yıl",yy:"%d yıl"},ordinal:function(a){return a+"."}};return t.default.locale(_,null,!0),_})); 22265 22266/***/ }), 22267
vendor: 4,919 bytes, lines 22268-22277
22268/***/ "./node_modules/dayjs/plugin/duration.js": 22269/*!***********************************************!*\ 22270 !*** ./node_modules/dayjs/plugin/duration.js ***! 22271 \***********************************************/ 22272/***/ (function(module) { 22273 22274!function(t,s){ true?module.exports=s():0}(this,(function(){"use strict";var t,s,n=1e3,i=6e4,e=36e5,r=864e5,o=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,u=31536e6,d=2628e6,a=/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/,h={years:u,months:d,days:r,hours:e,minutes:i,seconds:n,milliseconds:1,weeks:6048e5},c=function(t){return t instanceof g},f=function(t,s,n){return new g(t,n,s.$l)},m=function(t){return s.p(t)+"s"},l=function(t){return t<0},$=function(t){return l(t)?Math.ceil(t):Math.floor(t)},y=function(t){return Math.abs(t)},v=function(t,s){return t?l(t)?{negative:!0,format:""+y(t)+s}:{negative:!1,format:""+t+s}:{negative:!1,format:""}},g=function(){function l(t,s,n){var i=this;if(this.$d={},this.$l=n,void 0===t&&(this.$ms=0,this.parseFromMilliseconds()),s)return f(t*h[m(s)],this);if("number"==typeof t)return this.$ms=t,this.parseFromMilliseconds(),this;if("object"==typeof t)return Object.keys(t).forEach((function(s){i.$d[m(s)]=t[s]})),this.calMilliseconds(),this;if("string"==typeof t){var e=t.match(a);if(e){var r=e.slice(2).map((function(t){return null!=t?Number(t):0}));return this.$d.years=r[0],this.$d.months=r[1],this.$d.weeks=r[2],this.$d.days=r[3],this.$d.hours=r[4],this.$d.minutes=r[5],this.$d.seconds=r[6],this.calMilliseconds(),this}}return this}var y=l.prototype;return y.calMilliseconds=function(){var t=this;this.$ms=Object.keys(this.$d).reduce((function(s,n){return s+(t.$d[n]||0)*h[n]}),0)},y.parseFromMilliseconds=function(){var t=this.$ms;this.$d.years=$(t/u),t%=u,this.$d.months=$(t/d),t%=d,this.$d.days=$(t/r),t%=r,this.$d.hours=$(t/e),t%=e,this.$d.minutes=$(t/i),t%=i,this.$d.seconds=$(t/n),t%=n,this.$d.milliseconds=t},y.toISOString=function(){var t=v(this.$d.years,"Y"),s=v(this.$d.months,"M"),n=+this.$d.days||0;this.$d.weeks&&(n+=7*this.$d.weeks);var i=v(n,"D"),e=v(this.$d.hours,"H"),r=v(this.$d.minutes,"M"),o=this.$d.seconds||0;this.$d.milliseconds&&(o+=this.$d.milliseconds/1e3,o=Math.round(1e3*o)/1e3);var u=v(o,"S"),d=t.negative||s.negative||i.negative||e.negative||r.negative||u.negative,a=e.format||r.format||u.format?"T":"",h=(d?"-":"")+"P"+t.format+s.format+i.format+a+e.format+r.format+u.format;return"P"===h||"-P"===h?"P0D":h},y.toJSON=function(){return this.toISOString()},y.format=function(t){var n=t||"YYYY-MM-DDTHH:mm:ss",i={Y:this.$d.years,YY:s.s(this.$d.years,2,"0"),YYYY:s.s(this.$d.years,4,"0"),M:this.$d.months,MM:s.s(this.$d.months,2,"0"),D:this.$d.days,DD:s.s(this.$d.days,2,"0"),H:this.$d.hours,HH:s.s(this.$d.hours,2,"0"),m:this.$d.minutes,mm:s.s(this.$d.minutes,2,"0"),s:this.$d.seconds,ss:s.s(this.$d.seconds,2,"0"),SSS:s.s(this.$d.milliseconds,3,"0")};return n.replace(o,(function(t,s){return s||String(i[t])}))},y.as=function(t){return this.$ms/h[m(t)]},y.get=function(t){var s=this.$ms,n=m(t);return"milliseconds"===n?s%=1e3:s="weeks"===n?$(s/h[n]):this.$d[n],s||0},y.add=function(t,s,n){var i;return i=s?t*h[m(s)]:c(t)?t.$ms:f(t,this).$ms,f(this.$ms+i*(n?-1:1),this)},y.subtract=function(t,s){return this.add(t,s,!0)},y.locale=function(t){var s=this.clone();return s.$l=t,s},y.clone=function(){return f(this.$ms,this)},y.humanize=function(s){return t().add(this.$ms,"ms").locale(this.$l).fromNow(!s)},y.valueOf=function(){return this.asMilliseconds()},y.milliseconds=function(){return this.get("milliseconds")},y.asMilliseconds=function(){return this.as("milliseconds")},y.seconds=function(){return this.get("seconds")},y.asSeconds=function(){return this.as("seconds")},y.minutes=function(){return this.get("minutes")},y.asMinutes=function(){return this.as("minutes")},y.hours=function(){return this.get("hours")},y.asHours=function(){return this.as("hours")},y.days=function(){return this.get("days")},y.asDays=function(){return this.as("days")},y.weeks=function(){return this.get("weeks")},y.asWeeks=function(){return this.as("weeks")},y.months=function(){return this.get("months")},y.asMonths=function(){return this.as("months")},y.years=function(){return this.get("years")},y.asYears=function(){return this.as("years")},l}(),p=function(t,s,n){return t.add(s.years()*n,"y").add(s.months()*n,"M").add(s.days()*n,"d").add(s.hours()*n,"h").add(s.minutes()*n,"m").add(s.seconds()*n,"s").add(s.milliseconds()*n,"ms")};return function(n,i,e){t=e,s=e().$utils(),e.duration=function(t,s){var n=e.locale();return f(t,{$l:n},s)},e.isDuration=c;var r=i.prototype.add,o=i.prototype.subtract;i.prototype.add=function(t,s){return c(t)?p(this,t,1):r.bind(this)(t,s)},i.prototype.subtract=function(t,s){return c(t)?p(this,t,-1):o.bind(this)(t,s)}}})); 22275 22276/***/ }), 22277
vendor: 2,264 bytes, lines 22278-22287
22278/***/ "./node_modules/dayjs/plugin/timezone.js": 22279/*!***********************************************!*\ 22280 !*** ./node_modules/dayjs/plugin/timezone.js ***! 22281 \***********************************************/ 22282/***/ (function(module) { 22283 22284!function(t,e){ true?module.exports=e():0}(this,(function(){"use strict";var t={year:0,month:1,day:2,hour:3,minute:4,second:5},e={};return function(n,i,o){var r,a=function(t,n,i){void 0===i&&(i={});var o=new Date(t),r=function(t,n){void 0===n&&(n={});var i=n.timeZoneName||"short",o=t+"|"+i,r=e[o];return r||(r=new Intl.DateTimeFormat("en-US",{hour12:!1,timeZone:t,year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",second:"2-digit",timeZoneName:i}),e[o]=r),r}(n,i);return r.formatToParts(o)},u=function(e,n){for(var i=a(e,n),r=[],u=0;u<i.length;u+=1){var f=i[u],s=f.type,m=f.value,c=t[s];c>=0&&(r[c]=parseInt(m,10))}var d=r[3],l=24===d?0:d,h=r[0]+"-"+r[1]+"-"+r[2]+" "+l+":"+r[4]+":"+r[5]+":000",v=+e;return(o.utc(h).valueOf()-(v-=v%1e3))/6e4},f=i.prototype;f.tz=function(t,e){void 0===t&&(t=r);var n,i=this.utcOffset(),a=this.toDate(),u=a.toLocaleString("en-US",{timeZone:t}),f=Math.round((a-new Date(u))/1e3/60),s=15*-Math.round(a.getTimezoneOffset()/15)-f;if(!Number(s))n=this.utcOffset(0,e);else if(n=o(u,{locale:this.$L}).$set("millisecond",this.$ms).utcOffset(s,!0),e){var m=n.utcOffset();n=n.add(i-m,"minute")}return n.$x.$timezone=t,n},f.offsetName=function(t){var e=this.$x.$timezone||o.tz.guess(),n=a(this.valueOf(),e,{timeZoneName:t}).find((function(t){return"timezonename"===t.type.toLowerCase()}));return n&&n.value};var s=f.startOf;f.startOf=function(t,e){if(!this.$x||!this.$x.$timezone)return s.call(this,t,e);var n=o(this.format("YYYY-MM-DD HH:mm:ss:SSS"),{locale:this.$L});return s.call(n,t,e).tz(this.$x.$timezone,!0)},o.tz=function(t,e,n){var i=n&&e,a=n||e||r,f=u(+o(),a);if("string"!=typeof t)return o(t).tz(a);var s=function(t,e,n){var i=t-60*e*1e3,o=u(i,n);if(e===o)return[i,e];var r=u(i-=60*(o-e)*1e3,n);return o===r?[i,o]:[t-60*Math.min(o,r)*1e3,Math.max(o,r)]}(o.utc(t,i).valueOf(),f,a),m=s[0],c=s[1],d=o(m).utcOffset(c);return d.$x.$timezone=a,d},o.tz.guess=function(){return Intl.DateTimeFormat().resolvedOptions().timeZone},o.tz.setDefault=function(t){r=t}}})); 22285 22286/***/ }), 22287
vendor: 2,312 bytes, lines 22288-22297
22288/***/ "./node_modules/dayjs/plugin/utc.js": 22289/*!******************************************!*\ 22290 !*** ./node_modules/dayjs/plugin/utc.js ***! 22291 \******************************************/ 22292/***/ (function(module) { 22293 22294!function(t,i){ true?module.exports=i():0}(this,(function(){"use strict";var t="minute",i=/[+-]\d\d(?::?\d\d)?/g,e=/([+-]|\d\d)/g;return function(s,f,n){var u=f.prototype;n.utc=function(t){var i={date:t,utc:!0,args:arguments};return new f(i)},u.utc=function(i){var e=n(this.toDate(),{locale:this.$L,utc:!0});return i?e.add(this.utcOffset(),t):e},u.local=function(){return n(this.toDate(),{locale:this.$L,utc:!1})};var o=u.parse;u.parse=function(t){t.utc&&(this.$u=!0),this.$utils().u(t.$offset)||(this.$offset=t.$offset),o.call(this,t)};var r=u.init;u.init=function(){if(this.$u){var t=this.$d;this.$y=t.getUTCFullYear(),this.$M=t.getUTCMonth(),this.$D=t.getUTCDate(),this.$W=t.getUTCDay(),this.$H=t.getUTCHours(),this.$m=t.getUTCMinutes(),this.$s=t.getUTCSeconds(),this.$ms=t.getUTCMilliseconds()}else r.call(this)};var a=u.utcOffset;u.utcOffset=function(s,f){var n=this.$utils().u;if(n(s))return this.$u?0:n(this.$offset)?a.call(this):this.$offset;if("string"==typeof s&&(s=function(t){void 0===t&&(t="");var s=t.match(i);if(!s)return null;var f=(""+s[0]).match(e)||["-",0,0],n=f[0],u=60*+f[1]+ +f[2];return 0===u?0:"+"===n?u:-u}(s),null===s))return this;var u=Math.abs(s)<=16?60*s:s,o=this;if(f)return o.$offset=u,o.$u=0===s,o;if(0!==s){var r=this.$u?this.toDate().getTimezoneOffset():-1*this.utcOffset();(o=this.local().add(u+r,t)).$offset=u,o.$x.$localOffset=r}else o=this.utc();return o};var h=u.format;u.format=function(t){var i=t||(this.$u?"YYYY-MM-DDTHH:mm:ss[Z]":"");return h.call(this,i)},u.valueOf=function(){var t=this.$utils().u(this.$offset)?0:this.$offset+(this.$x.$localOffset||this.$d.getTimezoneOffset());return this.$d.valueOf()-6e4*t},u.isUTC=function(){return!!this.$u},u.toISOString=function(){return this.toDate().toISOString()},u.toString=function(){return this.toDate().toUTCString()};var l=u.toDate;u.toDate=function(t){return"s"===t&&this.$offset?n(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate():l.call(this)};var c=u.diff;u.diff=function(t,i,e){if(t&&this.$u===t.$u)return c.call(this,t,i,e);var s=this.local(),f=n(t).local();return c.call(s,f,i,e)}}})); 22295 22296/***/ }), 22297
vendor: 13,511 bytes, lines 22298-22893
22298/***/ "./node_modules/dot-object/index.js": 22299/*!******************************************!*\ 22300 !*** ./node_modules/dot-object/index.js ***! 22301 \******************************************/ 22302/***/ ((module) => { 22303 22304"use strict"; 22305 22306 22307function _process (v, mod) { 22308 var i 22309 var r 22310 22311 if (typeof mod === 'function') { 22312 r = mod(v) 22313 if (r !== undefined) { 22314 v = r 22315 } 22316 } else if (Array.isArray(mod)) { 22317 for (i = 0; i < mod.length; i++) { 22318 r = mod[i](v) 22319 if (r !== undefined) { 22320 v = r 22321 } 22322 } 22323 } 22324 22325 return v 22326} 22327 22328function parseKey (key, val) { 22329 // detect negative index notation 22330 if (key[0] === '-' && Array.isArray(val) && /^-\d+$/.test(key)) { 22331 return val.length + parseInt(key, 10) 22332 } 22333 return key 22334} 22335 22336function isIndex (k) { 22337 return /^\d+$/.test(k) 22338} 22339 22340function isObject (val) { 22341 return Object.prototype.toString.call(val) === '[object Object]' 22342} 22343 22344function isArrayOrObject (val) { 22345 return Object(val) === val 22346} 22347 22348function isEmptyObject (val) { 22349 return Object.keys(val).length === 0 22350} 22351 22352var blacklist = ['__proto__', 'prototype', 'constructor'] 22353var blacklistFilter = function (part) { return blacklist.indexOf(part) === -1 } 22354 22355function parsePath (path, sep) { 22356 if (path.indexOf('[') >= 0) { 22357 path = path.replace(/\[/g, sep).replace(/]/g, '') 22358 } 22359 22360 var parts = path.split(sep) 22361 22362 var check = parts.filter(blacklistFilter) 22363 22364 if (check.length !== parts.length) { 22365 throw Error('Refusing to update blacklisted property ' + path) 22366 } 22367 22368 return parts 22369} 22370 22371var hasOwnProperty = Object.prototype.hasOwnProperty 22372 22373function DotObject (separator, override, useArray, useBrackets) { 22374 if (!(this instanceof DotObject)) { 22375 return new DotObject(separator, override, useArray, useBrackets) 22376 } 22377 22378 if (typeof override === 'undefined') override = false 22379 if (typeof useArray === 'undefined') useArray = true 22380 if (typeof useBrackets === 'undefined') useBrackets = true 22381 this.separator = separator || '.' 22382 this.override = override 22383 this.useArray = useArray 22384 this.useBrackets = useBrackets 22385 this.keepArray = false 22386 22387 // contains touched arrays 22388 this.cleanup = [] 22389} 22390 22391var dotDefault = new DotObject('.', false, true, true) 22392function wrap (method) { 22393 return function () { 22394 return dotDefault[method].apply(dotDefault, arguments) 22395 } 22396} 22397 22398DotObject.prototype._fill = function (a, obj, v, mod) { 22399 var k = a.shift() 22400 22401 if (a.length > 0) { 22402 obj[k] = obj[k] || (this.useArray && isIndex(a[0]) ? [] : {}) 22403 22404 if (!isArrayOrObject(obj[k])) { 22405 if (this.override) { 22406 obj[k] = {} 22407 } else { 22408 if (!(isArrayOrObject(v) && isEmptyObject(v))) { 22409 throw new Error( 22410 'Trying to redefine `' + k + '` which is a ' + typeof obj[k] 22411 ) 22412 } 22413 22414 return 22415 } 22416 } 22417 22418 this._fill(a, obj[k], v, mod) 22419 } else { 22420 if (!this.override && isArrayOrObject(obj[k]) && !isEmptyObject(obj[k])) { 22421 if (!(isArrayOrObject(v) && isEmptyObject(v))) { 22422 throw new Error("Trying to redefine non-empty obj['" + k + "']") 22423 } 22424 22425 return 22426 } 22427 22428 obj[k] = _process(v, mod) 22429 } 22430} 22431 22432/** 22433 * 22434 * Converts an object with dotted-key/value pairs to it's expanded version 22435 * 22436 * Optionally transformed by a set of modifiers. 22437 * 22438 * Usage: 22439 * 22440 * var row = { 22441 * 'nr': 200, 22442 * 'doc.name': ' My Document ' 22443 * } 22444 * 22445 * var mods = { 22446 * 'doc.name': [_s.trim, _s.underscored] 22447 * } 22448 * 22449 * dot.object(row, mods) 22450 * 22451 * @param {Object} obj 22452 * @param {Object} mods 22453 */ 22454DotObject.prototype.object = function (obj, mods) { 22455 var self = this 22456 22457 Object.keys(obj).forEach(function (k) { 22458 var mod = mods === undefined ? null : mods[k] 22459 // normalize array notation. 22460 var ok = parsePath(k, self.separator).join(self.separator) 22461 22462 if (ok.indexOf(self.separator) !== -1) { 22463 self._fill(ok.split(self.separator), obj, obj[k], mod) 22464 delete obj[k] 22465 } else { 22466 obj[k] = _process(obj[k], mod) 22467 } 22468 }) 22469 22470 return obj 22471} 22472 22473/** 22474 * @param {String} path dotted path 22475 * @param {String} v value to be set 22476 * @param {Object} obj object to be modified 22477 * @param {Function|Array} mod optional modifier 22478 */ 22479DotObject.prototype.str = function (path, v, obj, mod) { 22480 var ok = parsePath(path, this.separator).join(this.separator) 22481 22482 if (path.indexOf(this.separator) !== -1) { 22483 this._fill(ok.split(this.separator), obj, v, mod) 22484 } else { 22485 obj[path] = _process(v, mod) 22486 } 22487 22488 return obj 22489} 22490 22491/** 22492 * 22493 * Pick a value from an object using dot notation. 22494 * 22495 * Optionally remove the value 22496 * 22497 * @param {String} path 22498 * @param {Object} obj 22499 * @param {Boolean} remove 22500 */ 22501DotObject.prototype.pick = function (path, obj, remove, reindexArray) { 22502 var i 22503 var keys 22504 var val 22505 var key 22506 var cp 22507 22508 keys = parsePath(path, this.separator) 22509 for (i = 0; i < keys.length; i++) { 22510 key = parseKey(keys[i], obj) 22511 if (obj && typeof obj === 'object' && key in obj) { 22512 if (i === keys.length - 1) { 22513 if (remove) { 22514 val = obj[key] 22515 if (reindexArray && Array.isArray(obj)) { 22516 obj.splice(key, 1) 22517 } else { 22518 delete obj[key] 22519 } 22520 if (Array.isArray(obj)) { 22521 cp = keys.slice(0, -1).join('.') 22522 if (this.cleanup.indexOf(cp) === -1) { 22523 this.cleanup.push(cp) 22524 } 22525 } 22526 return val 22527 } else { 22528 return obj[key] 22529 } 22530 } else { 22531 obj = obj[key] 22532 } 22533 } else { 22534 return undefined 22535 } 22536 } 22537 if (remove && Array.isArray(obj)) { 22538 obj = obj.filter(function (n) { 22539 return n !== undefined 22540 }) 22541 } 22542 return obj 22543} 22544/** 22545 * 22546 * Delete value from an object using dot notation. 22547 * 22548 * @param {String} path 22549 * @param {Object} obj 22550 * @return {any} The removed value 22551 */ 22552DotObject.prototype.delete = function (path, obj) { 22553 return this.remove(path, obj, true) 22554} 22555 22556/** 22557 * 22558 * Remove value from an object using dot notation. 22559 * 22560 * Will remove multiple items if path is an array. 22561 * In this case array indexes will be retained until all 22562 * removals have been processed. 22563 * 22564 * Use dot.delete() to automatically re-index arrays. 22565 * 22566 * @param {String|Array<String>} path 22567 * @param {Object} obj 22568 * @param {Boolean} reindexArray 22569 * @return {any} The removed value 22570 */ 22571DotObject.prototype.remove = function (path, obj, reindexArray) { 22572 var i 22573 22574 this.cleanup = [] 22575 if (Array.isArray(path)) { 22576 for (i = 0; i < path.length; i++) { 22577 this.pick(path[i], obj, true, reindexArray) 22578 } 22579 if (!reindexArray) { 22580 this._cleanup(obj) 22581 } 22582 return obj 22583 } else { 22584 return this.pick(path, obj, true, reindexArray) 22585 } 22586} 22587 22588DotObject.prototype._cleanup = function (obj) { 22589 var ret 22590 var i 22591 var keys 22592 var root 22593 if (this.cleanup.length) { 22594 for (i = 0; i < this.cleanup.length; i++) { 22595 keys = this.cleanup[i].split('.') 22596 root = keys.splice(0, -1).join('.') 22597 ret = root ? this.pick(root, obj) : obj 22598 ret = ret[keys[0]].filter(function (v) { 22599 return v !== undefined 22600 }) 22601 this.set(this.cleanup[i], ret, obj) 22602 } 22603 this.cleanup = [] 22604 } 22605} 22606 22607/** 22608 * Alias method for `dot.remove` 22609 * 22610 * Note: this is not an alias for dot.delete() 22611 * 22612 * @param {String|Array<String>} path 22613 * @param {Object} obj 22614 * @param {Boolean} reindexArray 22615 * @return {any} The removed value 22616 */ 22617DotObject.prototype.del = DotObject.prototype.remove 22618 22619/** 22620 * 22621 * Move a property from one place to the other. 22622 * 22623 * If the source path does not exist (undefined) 22624 * the target property will not be set. 22625 * 22626 * @param {String} source 22627 * @param {String} target 22628 * @param {Object} obj 22629 * @param {Function|Array} mods 22630 * @param {Boolean} merge 22631 */ 22632DotObject.prototype.move = function (source, target, obj, mods, merge) { 22633 if (typeof mods === 'function' || Array.isArray(mods)) { 22634 this.set(target, _process(this.pick(source, obj, true), mods), obj, merge) 22635 } else { 22636 merge = mods 22637 this.set(target, this.pick(source, obj, true), obj, merge) 22638 } 22639 22640 return obj 22641} 22642 22643/** 22644 * 22645 * Transfer a property from one object to another object. 22646 * 22647 * If the source path does not exist (undefined) 22648 * the property on the other object will not be set. 22649 * 22650 * @param {String} source 22651 * @param {String} target 22652 * @param {Object} obj1 22653 * @param {Object} obj2 22654 * @param {Function|Array} mods 22655 * @param {Boolean} merge 22656 */ 22657DotObject.prototype.transfer = function ( 22658 source, 22659 target, 22660 obj1, 22661 obj2, 22662 mods, 22663 merge 22664) { 22665 if (typeof mods === 'function' || Array.isArray(mods)) { 22666 this.set( 22667 target, 22668 _process(this.pick(source, obj1, true), mods), 22669 obj2, 22670 merge 22671 ) 22672 } else { 22673 merge = mods 22674 this.set(target, this.pick(source, obj1, true), obj2, merge) 22675 } 22676 22677 return obj2 22678} 22679 22680/** 22681 * 22682 * Copy a property from one object to another object. 22683 * 22684 * If the source path does not exist (undefined) 22685 * the property on the other object will not be set. 22686 * 22687 * @param {String} source 22688 * @param {String} target 22689 * @param {Object} obj1 22690 * @param {Object} obj2 22691 * @param {Function|Array} mods 22692 * @param {Boolean} merge 22693 */ 22694DotObject.prototype.copy = function (source, target, obj1, obj2, mods, merge) { 22695 if (typeof mods === 'function' || Array.isArray(mods)) { 22696 this.set( 22697 target, 22698 _process( 22699 // clone what is picked 22700 JSON.parse(JSON.stringify(this.pick(source, obj1, false))), 22701 mods 22702 ), 22703 obj2, 22704 merge 22705 ) 22706 } else { 22707 merge = mods 22708 this.set(target, this.pick(source, obj1, false), obj2, merge) 22709 } 22710 22711 return obj2 22712} 22713 22714/** 22715 * 22716 * Set a property on an object using dot notation. 22717 * 22718 * @param {String} path 22719 * @param {any} val 22720 * @param {Object} obj 22721 * @param {Boolean} merge 22722 */ 22723DotObject.prototype.set = function (path, val, obj, merge) { 22724 var i 22725 var k 22726 var keys 22727 var key 22728 22729 // Do not operate if the value is undefined. 22730 if (typeof val === 'undefined') { 22731 return obj 22732 } 22733 keys = parsePath(path, this.separator) 22734 22735 for (i = 0; i < keys.length; i++) { 22736 key = keys[i] 22737 if (i === keys.length - 1) { 22738 if (merge && isObject(val) && isObject(obj[key])) { 22739 for (k in val) { 22740 if (hasOwnProperty.call(val, k)) { 22741 obj[key][k] = val[k] 22742 } 22743 } 22744 } else if (merge && Array.isArray(obj[key]) && Array.isArray(val)) { 22745 for (var j = 0; j < val.length; j++) { 22746 obj[keys[i]].push(val[j]) 22747 } 22748 } else { 22749 obj[key] = val 22750 } 22751 } else if ( 22752 // force the value to be an object 22753 !hasOwnProperty.call(obj, key) || 22754 (!isObject(obj[key]) && !Array.isArray(obj[key])) 22755 ) { 22756 // initialize as array if next key is numeric 22757 if (/^\d+$/.test(keys[i + 1])) { 22758 obj[key] = [] 22759 } else { 22760 obj[key] = {} 22761 } 22762 } 22763 obj = obj[key] 22764 } 22765 return obj 22766} 22767 22768/** 22769 * 22770 * Transform an object 22771 * 22772 * Usage: 22773 * 22774 * var obj = { 22775 * "id": 1, 22776 * "some": { 22777 * "thing": "else" 22778 * } 22779 * } 22780 * 22781 * var transform = { 22782 * "id": "nr", 22783 * "some.thing": "name" 22784 * } 22785 * 22786 * var tgt = dot.transform(transform, obj) 22787 * 22788 * @param {Object} recipe Transform recipe 22789 * @param {Object} obj Object to be transformed 22790 * @param {Array} mods modifiers for the target 22791 */ 22792DotObject.prototype.transform = function (recipe, obj, tgt) { 22793 obj = obj || {} 22794 tgt = tgt || {} 22795 Object.keys(recipe).forEach( 22796 function (key) { 22797 this.set(recipe[key], this.pick(key, obj), tgt) 22798 }.bind(this) 22799 ) 22800 return tgt 22801} 22802 22803/** 22804 * 22805 * Convert object to dotted-key/value pair 22806 * 22807 * Usage: 22808 * 22809 * var tgt = dot.dot(obj) 22810 * 22811 * or 22812 * 22813 * var tgt = {} 22814 * dot.dot(obj, tgt) 22815 * 22816 * @param {Object} obj source object 22817 * @param {Object} tgt target object 22818 * @param {Array} path path array (internal) 22819 */ 22820DotObject.prototype.dot = function (obj, tgt, path) { 22821 tgt = tgt || {} 22822 path = path || [] 22823 var isArray = Array.isArray(obj) 22824 22825 Object.keys(obj).forEach( 22826 function (key) { 22827 var index = isArray && this.useBrackets ? '[' + key + ']' : key 22828 if ( 22829 isArrayOrObject(obj[key]) && 22830 ((isObject(obj[key]) && !isEmptyObject(obj[key])) || 22831 (Array.isArray(obj[key]) && !this.keepArray && obj[key].length !== 0)) 22832 ) { 22833 if (isArray && this.useBrackets) { 22834 var previousKey = path[path.length - 1] || '' 22835 return this.dot( 22836 obj[key], 22837 tgt, 22838 path.slice(0, -1).concat(previousKey + index) 22839 ) 22840 } else { 22841 return this.dot(obj[key], tgt, path.concat(index)) 22842 } 22843 } else { 22844 if (isArray && this.useBrackets) { 22845 tgt[path.join(this.separator).concat('[' + key + ']')] = obj[key] 22846 } else { 22847 tgt[path.concat(index).join(this.separator)] = obj[key] 22848 } 22849 } 22850 }.bind(this) 22851 ) 22852 return tgt 22853} 22854 22855DotObject.pick = wrap('pick') 22856DotObject.move = wrap('move') 22857DotObject.transfer = wrap('transfer') 22858DotObject.transform = wrap('transform') 22859DotObject.copy = wrap('copy') 22860DotObject.object = wrap('object') 22861DotObject.str = wrap('str') 22862DotObject.set = wrap('set') 22863DotObject.delete = wrap('delete') 22864DotObject.del = DotObject.remove = wrap('remove') 22865DotObject.dot = wrap('dot'); 22866['override', 'overwrite'].forEach(function (prop) { 22867 Object.defineProperty(DotObject, prop, { 22868 get: function () { 22869 return dotDefault.override 22870 }, 22871 set: function (val) { 22872 dotDefault.override = !!val 22873 } 22874 }) 22875}); 22876['useArray', 'keepArray', 'useBrackets'].forEach(function (prop) { 22877 Object.defineProperty(DotObject, prop, { 22878 get: function () { 22879 return dotDefault[prop] 22880 }, 22881 set: function (val) { 22882 dotDefault[prop] = val 22883 } 22884 }) 22885}) 22886 22887DotObject._process = _process 22888 22889module.exports = DotObject 22890 22891 22892/***/ }), 22893
vendor: 2,390 bytes, lines 22894-22988
22894/***/ "./node_modules/ieee754/index.js": 22895/*!***************************************!*\ 22896 !*** ./node_modules/ieee754/index.js ***! 22897 \***************************************/ 22898/***/ ((__unused_webpack_module, exports) => { 22899 22900/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */ 22901exports.read = function (buffer, offset, isLE, mLen, nBytes) { 22902 var e, m 22903 var eLen = (nBytes * 8) - mLen - 1 22904 var eMax = (1 << eLen) - 1 22905 var eBias = eMax >> 1 22906 var nBits = -7 22907 var i = isLE ? (nBytes - 1) : 0 22908 var d = isLE ? -1 : 1 22909 var s = buffer[offset + i] 22910 22911 i += d 22912 22913 e = s & ((1 << (-nBits)) - 1) 22914 s >>= (-nBits) 22915 nBits += eLen 22916 for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {} 22917 22918 m = e & ((1 << (-nBits)) - 1) 22919 e >>= (-nBits) 22920 nBits += mLen 22921 for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {} 22922 22923 if (e === 0) { 22924 e = 1 - eBias 22925 } else if (e === eMax) { 22926 return m ? NaN : ((s ? -1 : 1) * Infinity) 22927 } else { 22928 m = m + Math.pow(2, mLen) 22929 e = e - eBias 22930 } 22931 return (s ? -1 : 1) * m * Math.pow(2, e - mLen) 22932} 22933 22934exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { 22935 var e, m, c 22936 var eLen = (nBytes * 8) - mLen - 1 22937 var eMax = (1 << eLen) - 1 22938 var eBias = eMax >> 1 22939 var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) 22940 var i = isLE ? 0 : (nBytes - 1) 22941 var d = isLE ? 1 : -1 22942 var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 22943 22944 value = Math.abs(value) 22945 22946 if (isNaN(value) || value === Infinity) { 22947 m = isNaN(value) ? 1 : 0 22948 e = eMax 22949 } else { 22950 e = Math.floor(Math.log(value) / Math.LN2) 22951 if (value * (c = Math.pow(2, -e)) < 1) { 22952 e-- 22953 c *= 2 22954 } 22955 if (e + eBias >= 1) { 22956 value += rt / c 22957 } else { 22958 value += rt * Math.pow(2, 1 - eBias) 22959 } 22960 if (value * c >= 2) { 22961 e++ 22962 c /= 2 22963 } 22964 22965 if (e + eBias >= eMax) { 22966 m = 0 22967 e = eMax 22968 } else if (e + eBias >= 1) { 22969 m = ((value * c) - 1) * Math.pow(2, mLen) 22970 e = e + eBias 22971 } else { 22972 m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) 22973 e = 0 22974 } 22975 } 22976 22977 for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} 22978 22979 e = (e << mLen) | m 22980 eLen += mLen 22981 for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} 22982 22983 buffer[offset + i - d] |= s * 128 22984} 22985 22986 22987/***/ }), 22988
vendor: 342 bytes, lines 22989-23003
22989/***/ "./node_modules/isarray/index.js": 22990/*!***************************************!*\ 22991 !*** ./node_modules/isarray/index.js ***! 22992 \***************************************/ 22993/***/ ((module) => { 22994 22995var toString = {}.toString; 22996 22997module.exports = Array.isArray || function (arr) { 22998 return toString.call(arr) == '[object Array]'; 22999}; 23000 23001 23002/***/ }), 23003
vendor: 37,522 bytes, lines 23004-24343
23004/***/ "./node_modules/perfect-scrollbar/dist/perfect-scrollbar.esm.js": 23005/*!**********************************************************************!*\ 23006 !*** ./node_modules/perfect-scrollbar/dist/perfect-scrollbar.esm.js ***! 23007 \**********************************************************************/ 23008/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 23009 23010"use strict"; 23011__webpack_require__.r(__webpack_exports__); 23012/* harmony export */ __webpack_require__.d(__webpack_exports__, { 23013/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 23014/* harmony export */ }); 23015/*! 23016 * perfect-scrollbar v1.5.6 23017 * Copyright 2024 Hyunje Jun, MDBootstrap and Contributors 23018 * Licensed under MIT 23019 */ 23020 23021function get(element) { 23022 return getComputedStyle(element); 23023} 23024 23025function set(element, obj) { 23026 for (var key in obj) { 23027 var val = obj[key]; 23028 if (typeof val === 'number') { 23029 val = val + "px"; 23030 } 23031 element.style[key] = val; 23032 } 23033 return element; 23034} 23035 23036function div(className) { 23037 var div = document.createElement('div'); 23038 div.className = className; 23039 return div; 23040} 23041 23042var elMatches = 23043 typeof Element !== 'undefined' && 23044 (Element.prototype.matches || 23045 Element.prototype.webkitMatchesSelector || 23046 Element.prototype.mozMatchesSelector || 23047 Element.prototype.msMatchesSelector); 23048 23049function matches(element, query) { 23050 if (!elMatches) { 23051 throw new Error('No element matching method supported'); 23052 } 23053 23054 return elMatches.call(element, query); 23055} 23056 23057function remove(element) { 23058 if (element.remove) { 23059 element.remove(); 23060 } else { 23061 if (element.parentNode) { 23062 element.parentNode.removeChild(element); 23063 } 23064 } 23065} 23066 23067function queryChildren(element, selector) { 23068 return Array.prototype.filter.call(element.children, function (child) { return matches(child, selector); } 23069 ); 23070} 23071 23072var cls = { 23073 main: 'ps', 23074 rtl: 'ps__rtl', 23075 element: { 23076 thumb: function (x) { return ("ps__thumb-" + x); }, 23077 rail: function (x) { return ("ps__rail-" + x); }, 23078 consuming: 'ps__child--consume', 23079 }, 23080 state: { 23081 focus: 'ps--focus', 23082 clicking: 'ps--clicking', 23083 active: function (x) { return ("ps--active-" + x); }, 23084 scrolling: function (x) { return ("ps--scrolling-" + x); }, 23085 }, 23086}; 23087 23088/* 23089 * Helper methods 23090 */ 23091var scrollingClassTimeout = { x: null, y: null }; 23092 23093function addScrollingClass(i, x) { 23094 var classList = i.element.classList; 23095 var className = cls.state.scrolling(x); 23096 23097 if (classList.contains(className)) { 23098 clearTimeout(scrollingClassTimeout[x]); 23099 } else { 23100 classList.add(className); 23101 } 23102} 23103 23104function removeScrollingClass(i, x) { 23105 scrollingClassTimeout[x] = setTimeout( 23106 function () { return i.isAlive && i.element.classList.remove(cls.state.scrolling(x)); }, 23107 i.settings.scrollingThreshold 23108 ); 23109} 23110 23111function setScrollingClassInstantly(i, x) { 23112 addScrollingClass(i, x); 23113 removeScrollingClass(i, x); 23114} 23115 23116var EventElement = function EventElement(element) { 23117 this.element = element; 23118 this.handlers = {}; 23119}; 23120 23121var prototypeAccessors = { isEmpty: { configurable: true } }; 23122 23123EventElement.prototype.bind = function bind (eventName, handler) { 23124 if (typeof this.handlers[eventName] === 'undefined') { 23125 this.handlers[eventName] = []; 23126 } 23127 this.handlers[eventName].push(handler); 23128 this.element.addEventListener(eventName, handler, false); 23129}; 23130 23131EventElement.prototype.unbind = function unbind (eventName, target) { 23132 var this$1 = this; 23133 23134 this.handlers[eventName] = this.handlers[eventName].filter(function (handler) { 23135 if (target && handler !== target) { 23136 return true; 23137 } 23138 this$1.element.removeEventListener(eventName, handler, false); 23139 return false; 23140 }); 23141}; 23142 23143EventElement.prototype.unbindAll = function unbindAll () { 23144 for (var name in this.handlers) { 23145 this.unbind(name); 23146 } 23147}; 23148 23149prototypeAccessors.isEmpty.get = function () { 23150 var this$1 = this; 23151 23152 return Object.keys(this.handlers).every( 23153 function (key) { return this$1.handlers[key].length === 0; } 23154 ); 23155}; 23156 23157Object.defineProperties( EventElement.prototype, prototypeAccessors ); 23158 23159var EventManager = function EventManager() { 23160 this.eventElements = []; 23161}; 23162 23163EventManager.prototype.eventElement = function eventElement (element) { 23164 var ee = this.eventElements.filter(function (ee) { return ee.element === element; })[0]; 23165 if (!ee) { 23166 ee = new EventElement(element); 23167 this.eventElements.push(ee); 23168 } 23169 return ee; 23170}; 23171 23172EventManager.prototype.bind = function bind (element, eventName, handler) { 23173 this.eventElement(element).bind(eventName, handler); 23174}; 23175 23176EventManager.prototype.unbind = function unbind (element, eventName, handler) { 23177 var ee = this.eventElement(element); 23178 ee.unbind(eventName, handler); 23179 23180 if (ee.isEmpty) { 23181 // remove 23182 this.eventElements.splice(this.eventElements.indexOf(ee), 1); 23183 } 23184}; 23185 23186EventManager.prototype.unbindAll = function unbindAll () { 23187 this.eventElements.forEach(function (e) { return e.unbindAll(); }); 23188 this.eventElements = []; 23189}; 23190 23191EventManager.prototype.once = function once (element, eventName, handler) { 23192 var ee = this.eventElement(element); 23193 var onceHandler = function (evt) { 23194 ee.unbind(eventName, onceHandler); 23195 handler(evt); 23196 }; 23197 ee.bind(eventName, onceHandler); 23198}; 23199 23200function createEvent(name) { 23201 if (typeof window.CustomEvent === 'function') { 23202 return new CustomEvent(name); 23203 } 23204 23205 var evt = document.createEvent('CustomEvent'); 23206 evt.initCustomEvent(name, false, false, undefined); 23207 return evt; 23208} 23209 23210function processScrollDiff (i, axis, diff, useScrollingClass, forceFireReachEvent) { 23211 if ( useScrollingClass === void 0 ) useScrollingClass = true; 23212 if ( forceFireReachEvent === void 0 ) forceFireReachEvent = false; 23213 23214 var fields; 23215 if (axis === 'top') { 23216 fields = ['contentHeight', 'containerHeight', 'scrollTop', 'y', 'up', 'down']; 23217 } else if (axis === 'left') { 23218 fields = ['contentWidth', 'containerWidth', 'scrollLeft', 'x', 'left', 'right']; 23219 } else { 23220 throw new Error('A proper axis should be provided'); 23221 } 23222 23223 processScrollDiff$1(i, diff, fields, useScrollingClass, forceFireReachEvent); 23224} 23225 23226function processScrollDiff$1( 23227 i, 23228 diff, 23229 ref, 23230 useScrollingClass, 23231 forceFireReachEvent 23232) { 23233 var contentHeight = ref[0]; 23234 var containerHeight = ref[1]; 23235 var scrollTop = ref[2]; 23236 var y = ref[3]; 23237 var up = ref[4]; 23238 var down = ref[5]; 23239 if ( useScrollingClass === void 0 ) useScrollingClass = true; 23240 if ( forceFireReachEvent === void 0 ) forceFireReachEvent = false; 23241 23242 var element = i.element; 23243 23244 // reset reach 23245 i.reach[y] = null; 23246 23247 // 1 for subpixel rounding 23248 if (element[scrollTop] < 1) { 23249 i.reach[y] = 'start'; 23250 } 23251 23252 // 1 for subpixel rounding 23253 if (element[scrollTop] > i[contentHeight] - i[containerHeight] - 1) { 23254 i.reach[y] = 'end'; 23255 } 23256 23257 if (diff) { 23258 element.dispatchEvent(createEvent(("ps-scroll-" + y))); 23259 23260 if (diff < 0) { 23261 element.dispatchEvent(createEvent(("ps-scroll-" + up))); 23262 } else if (diff > 0) { 23263 element.dispatchEvent(createEvent(("ps-scroll-" + down))); 23264 } 23265 23266 if (useScrollingClass) { 23267 setScrollingClassInstantly(i, y); 23268 } 23269 } 23270 23271 if (i.reach[y] && (diff || forceFireReachEvent)) { 23272 element.dispatchEvent(createEvent(("ps-" + y + "-reach-" + (i.reach[y])))); 23273 } 23274} 23275 23276function toInt(x) { 23277 return parseInt(x, 10) || 0; 23278} 23279 23280function isEditable(el) { 23281 return ( 23282 matches(el, 'input,[contenteditable]') || 23283 matches(el, 'select,[contenteditable]') || 23284 matches(el, 'textarea,[contenteditable]') || 23285 matches(el, 'button,[contenteditable]') 23286 ); 23287} 23288 23289function outerWidth(element) { 23290 var styles = get(element); 23291 return ( 23292 toInt(styles.width) + 23293 toInt(styles.paddingLeft) + 23294 toInt(styles.paddingRight) + 23295 toInt(styles.borderLeftWidth) + 23296 toInt(styles.borderRightWidth) 23297 ); 23298} 23299 23300var env = { 23301 isWebKit: 23302 typeof document !== 'undefined' && 23303 'WebkitAppearance' in document.documentElement.style, 23304 supportsTouch: 23305 typeof window !== 'undefined' && 23306 ('ontouchstart' in window || 23307 ('maxTouchPoints' in window.navigator && 23308 window.navigator.maxTouchPoints > 0) || 23309 (window.DocumentTouch && document instanceof window.DocumentTouch)), 23310 supportsIePointer: 23311 typeof navigator !== 'undefined' && navigator.msMaxTouchPoints, 23312 isChrome: 23313 typeof navigator !== 'undefined' && 23314 /Chrome/i.test(navigator && navigator.userAgent), 23315}; 23316 23317/* eslint-disable no-lonely-if */ 23318 23319function updateGeometry (i) { 23320 var element = i.element; 23321 var roundedScrollTop = Math.floor(element.scrollTop); 23322 var rect = element.getBoundingClientRect(); 23323 23324 i.containerWidth = Math.floor(rect.width); 23325 i.containerHeight = Math.floor(rect.height); 23326 23327 i.contentWidth = element.scrollWidth; 23328 i.contentHeight = element.scrollHeight; 23329 23330 if (!element.contains(i.scrollbarXRail)) { 23331 // clean up and append 23332 queryChildren(element, cls.element.rail('x')).forEach(function (el) { return remove(el); }); 23333 element.appendChild(i.scrollbarXRail); 23334 } 23335 if (!element.contains(i.scrollbarYRail)) { 23336 // clean up and append 23337 queryChildren(element, cls.element.rail('y')).forEach(function (el) { return remove(el); }); 23338 element.appendChild(i.scrollbarYRail); 23339 } 23340 23341 if ( 23342 !i.settings.suppressScrollX && 23343 i.containerWidth + i.settings.scrollXMarginOffset < i.contentWidth 23344 ) { 23345 i.scrollbarXActive = true; 23346 i.railXWidth = i.containerWidth - i.railXMarginWidth; 23347 i.railXRatio = i.containerWidth / i.railXWidth; 23348 i.scrollbarXWidth = getThumbSize(i, toInt((i.railXWidth * i.containerWidth) / i.contentWidth)); 23349 i.scrollbarXLeft = toInt( 23350 ((i.negativeScrollAdjustment + element.scrollLeft) * (i.railXWidth - i.scrollbarXWidth)) / 23351 (i.contentWidth - i.containerWidth) 23352 ); 23353 } else { 23354 i.scrollbarXActive = false; 23355 } 23356 23357 if ( 23358 !i.settings.suppressScrollY && 23359 i.containerHeight + i.settings.scrollYMarginOffset < i.contentHeight 23360 ) { 23361 i.scrollbarYActive = true; 23362 i.railYHeight = i.containerHeight - i.railYMarginHeight; 23363 i.railYRatio = i.containerHeight / i.railYHeight; 23364 i.scrollbarYHeight = getThumbSize( 23365 i, 23366 toInt((i.railYHeight * i.containerHeight) / i.contentHeight) 23367 ); 23368 i.scrollbarYTop = toInt( 23369 (roundedScrollTop * (i.railYHeight - i.scrollbarYHeight)) / 23370 (i.contentHeight - i.containerHeight) 23371 ); 23372 } else { 23373 i.scrollbarYActive = false; 23374 } 23375 23376 if (i.scrollbarXLeft >= i.railXWidth - i.scrollbarXWidth) { 23377 i.scrollbarXLeft = i.railXWidth - i.scrollbarXWidth; 23378 } 23379 if (i.scrollbarYTop >= i.railYHeight - i.scrollbarYHeight) { 23380 i.scrollbarYTop = i.railYHeight - i.scrollbarYHeight; 23381 } 23382 23383 updateCss(element, i); 23384 23385 if (i.scrollbarXActive) { 23386 element.classList.add(cls.state.active('x')); 23387 } else { 23388 element.classList.remove(cls.state.active('x')); 23389 i.scrollbarXWidth = 0; 23390 i.scrollbarXLeft = 0; 23391 element.scrollLeft = i.isRtl === true ? i.contentWidth : 0; 23392 } 23393 if (i.scrollbarYActive) { 23394 element.classList.add(cls.state.active('y')); 23395 } else { 23396 element.classList.remove(cls.state.active('y')); 23397 i.scrollbarYHeight = 0; 23398 i.scrollbarYTop = 0; 23399 element.scrollTop = 0; 23400 } 23401} 23402 23403function getThumbSize(i, thumbSize) { 23404 if (i.settings.minScrollbarLength) { 23405 thumbSize = Math.max(thumbSize, i.settings.minScrollbarLength); 23406 } 23407 if (i.settings.maxScrollbarLength) { 23408 thumbSize = Math.min(thumbSize, i.settings.maxScrollbarLength); 23409 } 23410 return thumbSize; 23411} 23412 23413function updateCss(element, i) { 23414 var xRailOffset = { width: i.railXWidth }; 23415 var roundedScrollTop = Math.floor(element.scrollTop); 23416 23417 if (i.isRtl) { 23418 xRailOffset.left = 23419 i.negativeScrollAdjustment + element.scrollLeft + i.containerWidth - i.contentWidth; 23420 } else { 23421 xRailOffset.left = element.scrollLeft; 23422 } 23423 if (i.isScrollbarXUsingBottom) { 23424 xRailOffset.bottom = i.scrollbarXBottom - roundedScrollTop; 23425 } else { 23426 xRailOffset.top = i.scrollbarXTop + roundedScrollTop; 23427 } 23428 set(i.scrollbarXRail, xRailOffset); 23429 23430 var yRailOffset = { top: roundedScrollTop, height: i.railYHeight }; 23431 if (i.isScrollbarYUsingRight) { 23432 if (i.isRtl) { 23433 yRailOffset.right = 23434 i.contentWidth - 23435 (i.negativeScrollAdjustment + element.scrollLeft) - 23436 i.scrollbarYRight - 23437 i.scrollbarYOuterWidth - 23438 9; 23439 } else { 23440 yRailOffset.right = i.scrollbarYRight - element.scrollLeft; 23441 } 23442 } else { 23443 if (i.isRtl) { 23444 yRailOffset.left = 23445 i.negativeScrollAdjustment + 23446 element.scrollLeft + 23447 i.containerWidth * 2 - 23448 i.contentWidth - 23449 i.scrollbarYLeft - 23450 i.scrollbarYOuterWidth; 23451 } else { 23452 yRailOffset.left = i.scrollbarYLeft + element.scrollLeft; 23453 } 23454 } 23455 set(i.scrollbarYRail, yRailOffset); 23456 23457 set(i.scrollbarX, { 23458 left: i.scrollbarXLeft, 23459 width: i.scrollbarXWidth - i.railBorderXWidth, 23460 }); 23461 set(i.scrollbarY, { 23462 top: i.scrollbarYTop, 23463 height: i.scrollbarYHeight - i.railBorderYWidth, 23464 }); 23465} 23466 23467/* eslint-disable */ 23468 23469function clickRail (i) { 23470 // const element = i.element; 23471 23472 i.event.bind(i.scrollbarY, 'mousedown', function (e) { return e.stopPropagation(); }); 23473 i.event.bind(i.scrollbarYRail, 'mousedown', function (e) { 23474 var positionTop = e.pageY - window.pageYOffset - i.scrollbarYRail.getBoundingClientRect().top; 23475 var direction = positionTop > i.scrollbarYTop ? 1 : -1; 23476 23477 i.element.scrollTop += direction * i.containerHeight; 23478 updateGeometry(i); 23479 23480 e.stopPropagation(); 23481 }); 23482 23483 i.event.bind(i.scrollbarX, 'mousedown', function (e) { return e.stopPropagation(); }); 23484 i.event.bind(i.scrollbarXRail, 'mousedown', function (e) { 23485 var positionLeft = 23486 e.pageX - window.pageXOffset - i.scrollbarXRail.getBoundingClientRect().left; 23487 var direction = positionLeft > i.scrollbarXLeft ? 1 : -1; 23488 23489 i.element.scrollLeft += direction * i.containerWidth; 23490 updateGeometry(i); 23491 23492 e.stopPropagation(); 23493 }); 23494} 23495 23496var activeSlider = null; // Variable to track the currently active slider 23497 23498function setupScrollHandlers(i) { 23499 bindMouseScrollHandler(i, [ 23500 'containerHeight', 23501 'contentHeight', 23502 'pageY', 23503 'railYHeight', 23504 'scrollbarY', 23505 'scrollbarYHeight', 23506 'scrollTop', 23507 'y', 23508 'scrollbarYRail' ]); 23509 23510 bindMouseScrollHandler(i, [ 23511 'containerWidth', 23512 'contentWidth', 23513 'pageX', 23514 'railXWidth', 23515 'scrollbarX', 23516 'scrollbarXWidth', 23517 'scrollLeft', 23518 'x', 23519 'scrollbarXRail' ]); 23520} 23521 23522function bindMouseScrollHandler( 23523 i, 23524 ref 23525) { 23526 var containerDimension = ref[0]; 23527 var contentDimension = ref[1]; 23528 var pageAxis = ref[2]; 23529 var railDimension = ref[3]; 23530 var scrollbarAxis = ref[4]; 23531 var scrollbarDimension = ref[5]; 23532 var scrollAxis = ref[6]; 23533 var axis = ref[7]; 23534 var scrollbarRail = ref[8]; 23535 23536 var element = i.element; 23537 var startingScrollPosition = null; 23538 var startingMousePagePosition = null; 23539 var scrollBy = null; 23540 23541 function moveHandler(e) { 23542 if (e.touches && e.touches[0]) { 23543 e[pageAxis] = e.touches[0][("page" + (axis.toUpperCase()))]; 23544 } 23545 23546 // Only move if the active slider is the one we started with 23547 if (activeSlider === scrollbarAxis) { 23548 element[scrollAxis] = 23549 startingScrollPosition + scrollBy * (e[pageAxis] - startingMousePagePosition); 23550 addScrollingClass(i, axis); 23551 updateGeometry(i); 23552 23553 e.stopPropagation(); 23554 e.preventDefault(); 23555 } 23556 } 23557 23558 function endHandler() { 23559 removeScrollingClass(i, axis); 23560 i[scrollbarRail].classList.remove(cls.state.clicking); 23561 document.removeEventListener('mousemove', moveHandler); 23562 document.removeEventListener('mouseup', endHandler); 23563 document.removeEventListener('touchmove', moveHandler); 23564 document.removeEventListener('touchend', endHandler); 23565 activeSlider = null; // Reset active slider when interaction ends 23566 } 23567 23568 function bindMoves(e) { 23569 if (activeSlider === null) { 23570 // Only bind if no slider is currently active 23571 activeSlider = scrollbarAxis; // Set current slider as active 23572 23573 startingScrollPosition = element[scrollAxis]; 23574 if (e.touches) { 23575 e[pageAxis] = e.touches[0][("page" + (axis.toUpperCase()))]; 23576 } 23577 startingMousePagePosition = e[pageAxis]; 23578 scrollBy = 23579 (i[contentDimension] - i[containerDimension]) / (i[railDimension] - i[scrollbarDimension]); 23580 23581 if (!e.touches) { 23582 document.addEventListener('mousemove', moveHandler); 23583 document.addEventListener('mouseup', endHandler); 23584 } else { 23585 document.addEventListener('touchmove', moveHandler, { passive: false }); 23586 document.addEventListener('touchend', endHandler); 23587 } 23588 23589 i[scrollbarRail].classList.add(cls.state.clicking); 23590 } 23591 23592 e.stopPropagation(); 23593 if (e.cancelable) { 23594 e.preventDefault(); 23595 } 23596 } 23597 23598 i[scrollbarAxis].addEventListener('mousedown', bindMoves); 23599 i[scrollbarAxis].addEventListener('touchstart', bindMoves); 23600} 23601 23602/* eslint-disable */ 23603 23604function keyboard (i) { 23605 var element = i.element; 23606 23607 var elementHovered = function () { return matches(element, ':hover'); }; 23608 var scrollbarFocused = function () { return matches(i.scrollbarX, ':focus') || matches(i.scrollbarY, ':focus'); }; 23609 23610 function shouldPreventDefault(deltaX, deltaY) { 23611 var scrollTop = Math.floor(element.scrollTop); 23612 if (deltaX === 0) { 23613 if (!i.scrollbarYActive) { 23614 return false; 23615 } 23616 if ( 23617 (scrollTop === 0 && deltaY > 0) || 23618 (scrollTop >= i.contentHeight - i.containerHeight && deltaY < 0) 23619 ) { 23620 return !i.settings.wheelPropagation; 23621 } 23622 } 23623 23624 var scrollLeft = element.scrollLeft; 23625 if (deltaY === 0) { 23626 if (!i.scrollbarXActive) { 23627 return false; 23628 } 23629 if ( 23630 (scrollLeft === 0 && deltaX < 0) || 23631 (scrollLeft >= i.contentWidth - i.containerWidth && deltaX > 0) 23632 ) { 23633 return !i.settings.wheelPropagation; 23634 } 23635 } 23636 return true; 23637 } 23638 23639 i.event.bind(i.ownerDocument, 'keydown', function (e) { 23640 if ((e.isDefaultPrevented && e.isDefaultPrevented()) || e.defaultPrevented) { 23641 return; 23642 } 23643 23644 if (!elementHovered() && !scrollbarFocused()) { 23645 return; 23646 } 23647 23648 var activeElement = document.activeElement 23649 ? document.activeElement 23650 : i.ownerDocument.activeElement; 23651 if (activeElement) { 23652 if (activeElement.tagName === 'IFRAME') { 23653 activeElement = activeElement.contentDocument.activeElement; 23654 } else { 23655 // go deeper if element is a webcomponent 23656 while (activeElement.shadowRoot) { 23657 activeElement = activeElement.shadowRoot.activeElement; 23658 } 23659 } 23660 if (isEditable(activeElement)) { 23661 return; 23662 } 23663 } 23664 23665 var deltaX = 0; 23666 var deltaY = 0; 23667 23668 switch (e.which) { 23669 case 37: // left 23670 if (e.metaKey) { 23671 deltaX = -i.contentWidth; 23672 } else if (e.altKey) { 23673 deltaX = -i.containerWidth; 23674 } else { 23675 deltaX = -30; 23676 } 23677 break; 23678 case 38: // up 23679 if (e.metaKey) { 23680 deltaY = i.contentHeight; 23681 } else if (e.altKey) { 23682 deltaY = i.containerHeight; 23683 } else { 23684 deltaY = 30; 23685 } 23686 break; 23687 case 39: // right 23688 if (e.metaKey) { 23689 deltaX = i.contentWidth; 23690 } else if (e.altKey) { 23691 deltaX = i.containerWidth; 23692 } else { 23693 deltaX = 30; 23694 } 23695 break; 23696 case 40: // down 23697 if (e.metaKey) { 23698 deltaY = -i.contentHeight; 23699 } else if (e.altKey) { 23700 deltaY = -i.containerHeight; 23701 } else { 23702 deltaY = -30; 23703 } 23704 break; 23705 case 32: // space bar 23706 if (e.shiftKey) { 23707 deltaY = i.containerHeight; 23708 } else { 23709 deltaY = -i.containerHeight; 23710 } 23711 break; 23712 case 33: // page up 23713 deltaY = i.containerHeight; 23714 break; 23715 case 34: // page down 23716 deltaY = -i.containerHeight; 23717 break; 23718 case 36: // home 23719 deltaY = i.contentHeight; 23720 break; 23721 case 35: // end 23722 deltaY = -i.contentHeight; 23723 break; 23724 default: 23725 return; 23726 } 23727 23728 if (i.settings.suppressScrollX && deltaX !== 0) { 23729 return; 23730 } 23731 if (i.settings.suppressScrollY && deltaY !== 0) { 23732 return; 23733 } 23734 23735 element.scrollTop -= deltaY; 23736 element.scrollLeft += deltaX; 23737 updateGeometry(i); 23738 23739 if (shouldPreventDefault(deltaX, deltaY)) { 23740 e.preventDefault(); 23741 } 23742 }); 23743} 23744 23745/* eslint-disable */ 23746 23747function wheel (i) { 23748 var element = i.element; 23749 23750 function shouldPreventDefault(deltaX, deltaY) { 23751 var roundedScrollTop = Math.floor(element.scrollTop); 23752 var isTop = element.scrollTop === 0; 23753 var isBottom = roundedScrollTop + element.offsetHeight === element.scrollHeight; 23754 var isLeft = element.scrollLeft === 0; 23755 var isRight = element.scrollLeft + element.offsetWidth === element.scrollWidth; 23756 23757 var hitsBound; 23758 23759 // pick axis with primary direction 23760 if (Math.abs(deltaY) > Math.abs(deltaX)) { 23761 hitsBound = isTop || isBottom; 23762 } else { 23763 hitsBound = isLeft || isRight; 23764 } 23765 23766 return hitsBound ? !i.settings.wheelPropagation : true; 23767 } 23768 23769 function getDeltaFromEvent(e) { 23770 var deltaX = e.deltaX; 23771 var deltaY = -1 * e.deltaY; 23772 23773 if (typeof deltaX === 'undefined' || typeof deltaY === 'undefined') { 23774 // OS X Safari 23775 deltaX = (-1 * e.wheelDeltaX) / 6; 23776 deltaY = e.wheelDeltaY / 6; 23777 } 23778 23779 if (e.deltaMode && e.deltaMode === 1) { 23780 // Firefox in deltaMode 1: Line scrolling 23781 deltaX *= 10; 23782 deltaY *= 10; 23783 } 23784 23785 if (deltaX !== deltaX && deltaY !== deltaY /* NaN checks */) { 23786 // IE in some mouse drivers 23787 deltaX = 0; 23788 deltaY = e.wheelDelta; 23789 } 23790 23791 if (e.shiftKey) { 23792 // reverse axis with shift key 23793 return [-deltaY, -deltaX]; 23794 } 23795 return [deltaX, deltaY]; 23796 } 23797 23798 function shouldBeConsumedByChild(target, deltaX, deltaY) { 23799 // FIXME: this is a workaround for <select> issue in FF and IE #571 23800 if (!env.isWebKit && element.querySelector('select:focus')) { 23801 return true; 23802 } 23803 23804 if (!element.contains(target)) { 23805 return false; 23806 } 23807 23808 var cursor = target; 23809 23810 while (cursor && cursor !== element) { 23811 if (cursor.classList.contains(cls.element.consuming)) { 23812 return true; 23813 } 23814 23815 var style = get(cursor); 23816 23817 // if deltaY && vertical scrollable 23818 if (deltaY && style.overflowY.match(/(scroll|auto)/)) { 23819 var maxScrollTop = cursor.scrollHeight - cursor.clientHeight; 23820 if (maxScrollTop > 0) { 23821 if ( 23822 (cursor.scrollTop > 0 && deltaY < 0) || 23823 (cursor.scrollTop < maxScrollTop && deltaY > 0) 23824 ) { 23825 return true; 23826 } 23827 } 23828 } 23829 // if deltaX && horizontal scrollable 23830 if (deltaX && style.overflowX.match(/(scroll|auto)/)) { 23831 var maxScrollLeft = cursor.scrollWidth - cursor.clientWidth; 23832 if (maxScrollLeft > 0) { 23833 if ( 23834 (cursor.scrollLeft > 0 && deltaX < 0) || 23835 (cursor.scrollLeft < maxScrollLeft && deltaX > 0) 23836 ) { 23837 return true; 23838 } 23839 } 23840 } 23841 23842 cursor = cursor.parentNode; 23843 } 23844 23845 return false; 23846 } 23847 23848 function mousewheelHandler(e) { 23849 var ref = getDeltaFromEvent(e); 23850 var deltaX = ref[0]; 23851 var deltaY = ref[1]; 23852 23853 if (shouldBeConsumedByChild(e.target, deltaX, deltaY)) { 23854 return; 23855 } 23856 23857 var shouldPrevent = false; 23858 if (!i.settings.useBothWheelAxes) { 23859 // deltaX will only be used for horizontal scrolling and deltaY will 23860 // only be used for vertical scrolling - this is the default 23861 element.scrollTop -= deltaY * i.settings.wheelSpeed; 23862 element.scrollLeft += deltaX * i.settings.wheelSpeed; 23863 } else if (i.scrollbarYActive && !i.scrollbarXActive) { 23864 // only vertical scrollbar is active and useBothWheelAxes option is 23865 // active, so let's scroll vertical bar using both mouse wheel axes 23866 if (deltaY) { 23867 element.scrollTop -= deltaY * i.settings.wheelSpeed; 23868 } else { 23869 element.scrollTop += deltaX * i.settings.wheelSpeed; 23870 } 23871 shouldPrevent = true; 23872 } else if (i.scrollbarXActive && !i.scrollbarYActive) { 23873 // useBothWheelAxes and only horizontal bar is active, so use both 23874 // wheel axes for horizontal bar 23875 if (deltaX) { 23876 element.scrollLeft += deltaX * i.settings.wheelSpeed; 23877 } else { 23878 element.scrollLeft -= deltaY * i.settings.wheelSpeed; 23879 } 23880 shouldPrevent = true; 23881 } 23882 23883 updateGeometry(i); 23884 23885 shouldPrevent = shouldPrevent || shouldPreventDefault(deltaX, deltaY); 23886 if (shouldPrevent && !e.ctrlKey) { 23887 e.stopPropagation(); 23888 e.preventDefault(); 23889 } 23890 } 23891 23892 if (typeof window.onwheel !== 'undefined') { 23893 i.event.bind(element, 'wheel', mousewheelHandler); 23894 } else if (typeof window.onmousewheel !== 'undefined') { 23895 i.event.bind(element, 'mousewheel', mousewheelHandler); 23896 } 23897} 23898 23899function touch (i) { 23900 if (!env.supportsTouch && !env.supportsIePointer) { 23901 return; 23902 } 23903 23904 var element = i.element; 23905 23906 var state = { 23907 startOffset: {}, 23908 startTime: 0, 23909 speed: {}, 23910 easingLoop: null, 23911 }; 23912 23913 function shouldPrevent(deltaX, deltaY) { 23914 var scrollTop = Math.floor(element.scrollTop); 23915 var scrollLeft = element.scrollLeft; 23916 var magnitudeX = Math.abs(deltaX); 23917 var magnitudeY = Math.abs(deltaY); 23918 23919 if (magnitudeY > magnitudeX) { 23920 // user is perhaps trying to swipe up/down the page 23921 23922 if ( 23923 (deltaY < 0 && scrollTop === i.contentHeight - i.containerHeight) || 23924 (deltaY > 0 && scrollTop === 0) 23925 ) { 23926 // set prevent for mobile Chrome refresh 23927 return window.scrollY === 0 && deltaY > 0 && env.isChrome; 23928 } 23929 } else if (magnitudeX > magnitudeY) { 23930 // user is perhaps trying to swipe left/right across the page 23931 23932 if ( 23933 (deltaX < 0 && scrollLeft === i.contentWidth - i.containerWidth) || 23934 (deltaX > 0 && scrollLeft === 0) 23935 ) { 23936 return true; 23937 } 23938 } 23939 23940 return true; 23941 } 23942 23943 function applyTouchMove(differenceX, differenceY) { 23944 element.scrollTop -= differenceY; 23945 element.scrollLeft -= differenceX; 23946 23947 updateGeometry(i); 23948 } 23949 23950 function getTouch(e) { 23951 if (e.targetTouches) { 23952 return e.targetTouches[0]; 23953 } 23954 // Maybe IE pointer 23955 return e; 23956 } 23957 23958 function shouldHandle(e) { 23959 if (e.target === i.scrollbarX || e.target === i.scrollbarY) { 23960 return false; 23961 } 23962 if (e.pointerType && e.pointerType === 'pen' && e.buttons === 0) { 23963 return false; 23964 } 23965 if (e.targetTouches && e.targetTouches.length === 1) { 23966 return true; 23967 } 23968 if (e.pointerType && e.pointerType !== 'mouse' && e.pointerType !== e.MSPOINTER_TYPE_MOUSE) { 23969 return true; 23970 } 23971 return false; 23972 } 23973 23974 function touchStart(e) { 23975 if (!shouldHandle(e)) { 23976 return; 23977 } 23978 23979 var touch = getTouch(e); 23980 23981 state.startOffset.pageX = touch.pageX; 23982 state.startOffset.pageY = touch.pageY; 23983 23984 state.startTime = new Date().getTime(); 23985 23986 if (state.easingLoop !== null) { 23987 clearInterval(state.easingLoop); 23988 } 23989 } 23990 23991 function shouldBeConsumedByChild(target, deltaX, deltaY) { 23992 if (!element.contains(target)) { 23993 return false; 23994 } 23995 23996 var cursor = target; 23997 23998 while (cursor && cursor !== element) { 23999 if (cursor.classList.contains(cls.element.consuming)) { 24000 return true; 24001 } 24002 24003 var style = get(cursor); 24004 24005 // if deltaY && vertical scrollable 24006 if (deltaY && style.overflowY.match(/(scroll|auto)/)) { 24007 var maxScrollTop = cursor.scrollHeight - cursor.clientHeight; 24008 if (maxScrollTop > 0) { 24009 if ( 24010 (cursor.scrollTop > 0 && deltaY < 0) || 24011 (cursor.scrollTop < maxScrollTop && deltaY > 0) 24012 ) { 24013 return true; 24014 } 24015 } 24016 } 24017 // if deltaX && horizontal scrollable 24018 if (deltaX && style.overflowX.match(/(scroll|auto)/)) { 24019 var maxScrollLeft = cursor.scrollWidth - cursor.clientWidth; 24020 if (maxScrollLeft > 0) { 24021 if ( 24022 (cursor.scrollLeft > 0 && deltaX < 0) || 24023 (cursor.scrollLeft < maxScrollLeft && deltaX > 0) 24024 ) { 24025 return true; 24026 } 24027 } 24028 } 24029 24030 cursor = cursor.parentNode; 24031 } 24032 24033 return false; 24034 } 24035 24036 function touchMove(e) { 24037 if (shouldHandle(e)) { 24038 var touch = getTouch(e); 24039 24040 var currentOffset = { pageX: touch.pageX, pageY: touch.pageY }; 24041 24042 var differenceX = currentOffset.pageX - state.startOffset.pageX; 24043 var differenceY = currentOffset.pageY - state.startOffset.pageY; 24044 24045 if (shouldBeConsumedByChild(e.target, differenceX, differenceY)) { 24046 return; 24047 } 24048 24049 applyTouchMove(differenceX, differenceY); 24050 state.startOffset = currentOffset; 24051 24052 var currentTime = new Date().getTime(); 24053 24054 var timeGap = currentTime - state.startTime; 24055 if (timeGap > 0) { 24056 state.speed.x = differenceX / timeGap; 24057 state.speed.y = differenceY / timeGap; 24058 state.startTime = currentTime; 24059 } 24060 24061 if (shouldPrevent(differenceX, differenceY)) { 24062 // Prevent the default behavior if the event is cancelable 24063 if (e.cancelable) { 24064 e.preventDefault(); 24065 } 24066 } 24067 } 24068 } 24069 24070 function touchEnd() { 24071 if (i.settings.swipeEasing) { 24072 clearInterval(state.easingLoop); 24073 state.easingLoop = setInterval(function () { 24074 if (i.isInitialized) { 24075 clearInterval(state.easingLoop); 24076 return; 24077 } 24078 24079 if (!state.speed.x && !state.speed.y) { 24080 clearInterval(state.easingLoop); 24081 return; 24082 } 24083 24084 if (Math.abs(state.speed.x) < 0.01 && Math.abs(state.speed.y) < 0.01) { 24085 clearInterval(state.easingLoop); 24086 return; 24087 } 24088 24089 applyTouchMove(state.speed.x * 30, state.speed.y * 30); 24090 24091 state.speed.x *= 0.8; 24092 state.speed.y *= 0.8; 24093 }, 10); 24094 } 24095 } 24096 24097 if (env.supportsTouch) { 24098 i.event.bind(element, 'touchstart', touchStart); 24099 i.event.bind(element, 'touchmove', touchMove); 24100 i.event.bind(element, 'touchend', touchEnd); 24101 } else if (env.supportsIePointer) { 24102 if (window.PointerEvent) { 24103 i.event.bind(element, 'pointerdown', touchStart); 24104 i.event.bind(element, 'pointermove', touchMove); 24105 i.event.bind(element, 'pointerup', touchEnd); 24106 } else if (window.MSPointerEvent) { 24107 i.event.bind(element, 'MSPointerDown', touchStart); 24108 i.event.bind(element, 'MSPointerMove', touchMove); 24109 i.event.bind(element, 'MSPointerUp', touchEnd); 24110 } 24111 } 24112} 24113 24114/* eslint-disable */ 24115 24116var defaultSettings = function () { return ({ 24117 handlers: ['click-rail', 'drag-thumb', 'keyboard', 'wheel', 'touch'], 24118 maxScrollbarLength: null, 24119 minScrollbarLength: null, 24120 scrollingThreshold: 1000, 24121 scrollXMarginOffset: 0, 24122 scrollYMarginOffset: 0, 24123 suppressScrollX: false, 24124 suppressScrollY: false, 24125 swipeEasing: true, 24126 useBothWheelAxes: false, 24127 wheelPropagation: true, 24128 wheelSpeed: 1, 24129}); }; 24130 24131var handlers = { 24132 'click-rail': clickRail, 24133 'drag-thumb': setupScrollHandlers, 24134 keyboard: keyboard, 24135 wheel: wheel, 24136 touch: touch, 24137}; 24138 24139var PerfectScrollbar = function PerfectScrollbar(element, userSettings) { 24140 var this$1 = this; 24141 if ( userSettings === void 0 ) userSettings = {}; 24142 24143 if (typeof element === 'string') { 24144 element = document.querySelector(element); 24145 } 24146 24147 if (!element || !element.nodeName) { 24148 throw new Error('no element is specified to initialize PerfectScrollbar'); 24149 } 24150 24151 this.element = element; 24152 24153 element.classList.add(cls.main); 24154 24155 this.settings = defaultSettings(); 24156 for (var key in userSettings) { 24157 this.settings[key] = userSettings[key]; 24158 } 24159 24160 this.containerWidth = null; 24161 this.containerHeight = null; 24162 this.contentWidth = null; 24163 this.contentHeight = null; 24164 24165 var focus = function () { return element.classList.add(cls.state.focus); }; 24166 var blur = function () { return element.classList.remove(cls.state.focus); }; 24167 24168 this.isRtl = get(element).direction === 'rtl'; 24169 if (this.isRtl === true) { 24170 element.classList.add(cls.rtl); 24171 } 24172 this.isNegativeScroll = (function () { 24173 var originalScrollLeft = element.scrollLeft; 24174 var result = null; 24175 element.scrollLeft = -1; 24176 result = element.scrollLeft < 0; 24177 element.scrollLeft = originalScrollLeft; 24178 return result; 24179 })(); 24180 this.negativeScrollAdjustment = this.isNegativeScroll 24181 ? element.scrollWidth - element.clientWidth 24182 : 0; 24183 this.event = new EventManager(); 24184 this.ownerDocument = element.ownerDocument || document; 24185 24186 this.scrollbarXRail = div(cls.element.rail('x')); 24187 element.appendChild(this.scrollbarXRail); 24188 this.scrollbarX = div(cls.element.thumb('x')); 24189 this.scrollbarXRail.appendChild(this.scrollbarX); 24190 this.scrollbarX.setAttribute('tabindex', 0); 24191 this.event.bind(this.scrollbarX, 'focus', focus); 24192 this.event.bind(this.scrollbarX, 'blur', blur); 24193 this.scrollbarXActive = null; 24194 this.scrollbarXWidth = null; 24195 this.scrollbarXLeft = null; 24196 var railXStyle = get(this.scrollbarXRail); 24197 this.scrollbarXBottom = parseInt(railXStyle.bottom, 10); 24198 if (isNaN(this.scrollbarXBottom)) { 24199 this.isScrollbarXUsingBottom = false; 24200 this.scrollbarXTop = toInt(railXStyle.top); 24201 } else { 24202 this.isScrollbarXUsingBottom = true; 24203 } 24204 this.railBorderXWidth = toInt(railXStyle.borderLeftWidth) + toInt(railXStyle.borderRightWidth); 24205 // Set rail to display:block to calculate margins 24206 set(this.scrollbarXRail, { display: 'block' }); 24207 this.railXMarginWidth = toInt(railXStyle.marginLeft) + toInt(railXStyle.marginRight); 24208 set(this.scrollbarXRail, { display: '' }); 24209 this.railXWidth = null; 24210 this.railXRatio = null; 24211 24212 this.scrollbarYRail = div(cls.element.rail('y')); 24213 element.appendChild(this.scrollbarYRail); 24214 this.scrollbarY = div(cls.element.thumb('y')); 24215 this.scrollbarYRail.appendChild(this.scrollbarY); 24216 this.scrollbarY.setAttribute('tabindex', 0); 24217 this.event.bind(this.scrollbarY, 'focus', focus); 24218 this.event.bind(this.scrollbarY, 'blur', blur); 24219 this.scrollbarYActive = null; 24220 this.scrollbarYHeight = null; 24221 this.scrollbarYTop = null; 24222 var railYStyle = get(this.scrollbarYRail); 24223 this.scrollbarYRight = parseInt(railYStyle.right, 10); 24224 if (isNaN(this.scrollbarYRight)) { 24225 this.isScrollbarYUsingRight = false; 24226 this.scrollbarYLeft = toInt(railYStyle.left); 24227 } else { 24228 this.isScrollbarYUsingRight = true; 24229 } 24230 this.scrollbarYOuterWidth = this.isRtl ? outerWidth(this.scrollbarY) : null; 24231 this.railBorderYWidth = toInt(railYStyle.borderTopWidth) + toInt(railYStyle.borderBottomWidth); 24232 set(this.scrollbarYRail, { display: 'block' }); 24233 this.railYMarginHeight = toInt(railYStyle.marginTop) + toInt(railYStyle.marginBottom); 24234 set(this.scrollbarYRail, { display: '' }); 24235 this.railYHeight = null; 24236 this.railYRatio = null; 24237 24238 this.reach = { 24239 x: 24240 element.scrollLeft <= 0 24241 ? 'start' 24242 : element.scrollLeft >= this.contentWidth - this.containerWidth 24243 ? 'end' 24244 : null, 24245 y: 24246 element.scrollTop <= 0 24247 ? 'start' 24248 : element.scrollTop >= this.contentHeight - this.containerHeight 24249 ? 'end' 24250 : null, 24251 }; 24252 24253 this.isAlive = true; 24254 24255 this.settings.handlers.forEach(function (handlerName) { return handlers[handlerName](this$1); }); 24256 24257 this.lastScrollTop = Math.floor(element.scrollTop); // for onScroll only 24258 this.lastScrollLeft = element.scrollLeft; // for onScroll only 24259 this.event.bind(this.element, 'scroll', function (e) { return this$1.onScroll(e); }); 24260 updateGeometry(this); 24261}; 24262 24263PerfectScrollbar.prototype.update = function update () { 24264 if (!this.isAlive) { 24265 return; 24266 } 24267 24268 // Recalcuate negative scrollLeft adjustment 24269 this.negativeScrollAdjustment = this.isNegativeScroll 24270 ? this.element.scrollWidth - this.element.clientWidth 24271 : 0; 24272 24273 // Recalculate rail margins 24274 set(this.scrollbarXRail, { display: 'block' }); 24275 set(this.scrollbarYRail, { display: 'block' }); 24276 this.railXMarginWidth = 24277 toInt(get(this.scrollbarXRail).marginLeft) + 24278 toInt(get(this.scrollbarXRail).marginRight); 24279 this.railYMarginHeight = 24280 toInt(get(this.scrollbarYRail).marginTop) + 24281 toInt(get(this.scrollbarYRail).marginBottom); 24282 24283 // Hide scrollbars not to affect scrollWidth and scrollHeight 24284 set(this.scrollbarXRail, { display: 'none' }); 24285 set(this.scrollbarYRail, { display: 'none' }); 24286 24287 updateGeometry(this); 24288 24289 processScrollDiff(this, 'top', 0, false, true); 24290 processScrollDiff(this, 'left', 0, false, true); 24291 24292 set(this.scrollbarXRail, { display: '' }); 24293 set(this.scrollbarYRail, { display: '' }); 24294}; 24295 24296PerfectScrollbar.prototype.onScroll = function onScroll (e) { 24297 if (!this.isAlive) { 24298 return; 24299 } 24300 24301 updateGeometry(this); 24302 processScrollDiff(this, 'top', this.element.scrollTop - this.lastScrollTop); 24303 processScrollDiff(this, 'left', this.element.scrollLeft - this.lastScrollLeft); 24304 24305 this.lastScrollTop = Math.floor(this.element.scrollTop); 24306 this.lastScrollLeft = this.element.scrollLeft; 24307}; 24308 24309PerfectScrollbar.prototype.destroy = function destroy () { 24310 if (!this.isAlive) { 24311 return; 24312 } 24313 24314 this.event.unbindAll(); 24315 remove(this.scrollbarX); 24316 remove(this.scrollbarY); 24317 remove(this.scrollbarXRail); 24318 remove(this.scrollbarYRail); 24319 this.removePsClasses(); 24320 24321 // unset elements 24322 this.element = null; 24323 this.scrollbarX = null; 24324 this.scrollbarY = null; 24325 this.scrollbarXRail = null; 24326 this.scrollbarYRail = null; 24327 24328 this.isAlive = false; 24329}; 24330 24331PerfectScrollbar.prototype.removePsClasses = function removePsClasses () { 24332 this.element.className = this.element.className 24333 .split(' ') 24334 .filter(function (name) { return !name.match(/^ps([-_].+|)$/); }) 24335 .join(' '); 24336}; 24337 24338/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (PerfectScrollbar); 24339//# sourceMappingURL=perfect-scrollbar.esm.js.map 24340 24341 24342/***/ }), 24343
vendor: 5,636 bytes, lines 24344-24537
24344/***/ "./node_modules/process/browser.js": 24345/*!*****************************************!*\ 24346 !*** ./node_modules/process/browser.js ***! 24347 \*****************************************/ 24348/***/ ((module) => { 24349 24350// shim for using process in browser 24351var process = module.exports = {}; 24352 24353// cached from whatever global is present so that test runners that stub it 24354// don't break things. But we need to wrap it in a try catch in case it is 24355// wrapped in strict mode code which doesn't define any globals. It's inside a 24356// function because try/catches deoptimize in certain engines. 24357 24358var cachedSetTimeout; 24359var cachedClearTimeout; 24360 24361function defaultSetTimout() { 24362 throw new Error('setTimeout has not been defined'); 24363} 24364function defaultClearTimeout () { 24365 throw new Error('clearTimeout has not been defined'); 24366} 24367(function () { 24368 try { 24369 if (typeof setTimeout === 'function') { 24370 cachedSetTimeout = setTimeout; 24371 } else { 24372 cachedSetTimeout = defaultSetTimout; 24373 } 24374 } catch (e) { 24375 cachedSetTimeout = defaultSetTimout; 24376 } 24377 try { 24378 if (typeof clearTimeout === 'function') { 24379 cachedClearTimeout = clearTimeout; 24380 } else { 24381 cachedClearTimeout = defaultClearTimeout; 24382 } 24383 } catch (e) { 24384 cachedClearTimeout = defaultClearTimeout; 24385 } 24386} ()) 24387function runTimeout(fun) { 24388 if (cachedSetTimeout === setTimeout) { 24389 //normal enviroments in sane situations 24390 return setTimeout(fun, 0); 24391 } 24392 // if setTimeout wasn't available but was latter defined 24393 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { 24394 cachedSetTimeout = setTimeout; 24395 return setTimeout(fun, 0); 24396 } 24397 try { 24398 // when when somebody has screwed with setTimeout but no I.E. maddness 24399 return cachedSetTimeout(fun, 0); 24400 } catch(e){ 24401 try { 24402 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 24403 return cachedSetTimeout.call(null, fun, 0); 24404 } catch(e){ 24405 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error 24406 return cachedSetTimeout.call(this, fun, 0); 24407 } 24408 } 24409 24410 24411} 24412function runClearTimeout(marker) { 24413 if (cachedClearTimeout === clearTimeout) { 24414 //normal enviroments in sane situations 24415 return clearTimeout(marker); 24416 } 24417 // if clearTimeout wasn't available but was latter defined 24418 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { 24419 cachedClearTimeout = clearTimeout; 24420 return clearTimeout(marker); 24421 } 24422 try { 24423 // when when somebody has screwed with setTimeout but no I.E. maddness 24424 return cachedClearTimeout(marker); 24425 } catch (e){ 24426 try { 24427 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 24428 return cachedClearTimeout.call(null, marker); 24429 } catch (e){ 24430 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. 24431 // Some versions of I.E. have different rules for clearTimeout vs setTimeout 24432 return cachedClearTimeout.call(this, marker); 24433 } 24434 } 24435 24436 24437 24438} 24439var queue = []; 24440var draining = false; 24441var currentQueue; 24442var queueIndex = -1; 24443 24444function cleanUpNextTick() { 24445 if (!draining || !currentQueue) { 24446 return; 24447 } 24448 draining = false; 24449 if (currentQueue.length) { 24450 queue = currentQueue.concat(queue); 24451 } else { 24452 queueIndex = -1; 24453 } 24454 if (queue.length) { 24455 drainQueue(); 24456 } 24457} 24458 24459function drainQueue() { 24460 if (draining) { 24461 return; 24462 } 24463 var timeout = runTimeout(cleanUpNextTick); 24464 draining = true; 24465 24466 var len = queue.length; 24467 while(len) { 24468 currentQueue = queue; 24469 queue = []; 24470 while (++queueIndex < len) { 24471 if (currentQueue) { 24472 currentQueue[queueIndex].run(); 24473 } 24474 } 24475 queueIndex = -1; 24476 len = queue.length; 24477 } 24478 currentQueue = null; 24479 draining = false; 24480 runClearTimeout(timeout); 24481} 24482 24483process.nextTick = function (fun) { 24484 var args = new Array(arguments.length - 1); 24485 if (arguments.length > 1) { 24486 for (var i = 1; i < arguments.length; i++) { 24487 args[i - 1] = arguments[i]; 24488 } 24489 } 24490 queue.push(new Item(fun, args)); 24491 if (queue.length === 1 && !draining) { 24492 runTimeout(drainQueue); 24493 } 24494}; 24495 24496// v8 likes predictible objects 24497function Item(fun, array) { 24498 this.fun = fun; 24499 this.array = array; 24500} 24501Item.prototype.run = function () { 24502 this.fun.apply(null, this.array); 24503}; 24504process.title = 'browser'; 24505process.browser = true; 24506process.env = {}; 24507process.argv = []; 24508process.version = ''; // empty string to avoid regexp issues 24509process.versions = {}; 24510 24511function noop() {} 24512 24513process.on = noop; 24514process.addListener = noop; 24515process.once = noop; 24516process.off = noop; 24517process.removeListener = noop; 24518process.removeAllListeners = noop; 24519process.emit = noop; 24520process.prependListener = noop; 24521process.prependOnceListener = noop; 24522 24523process.listeners = function (name) { return [] } 24524 24525process.binding = function (name) { 24526 throw new Error('process.binding is not supported'); 24527}; 24528 24529process.cwd = function () { return '/' }; 24530process.chdir = function (dir) { 24531 throw new Error('process.chdir is not supported'); 24532}; 24533process.umask = function() { return 0; }; 24534 24535 24536/***/ }), 24537
vendor: 7,200 bytes, lines 24538-24816
24538/***/ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js": 24539/*!****************************************************************************!*\ 24540 !*** ./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js ***! 24541 \****************************************************************************/ 24542/***/ ((module, __unused_webpack_exports, __webpack_require__) => { 24543 24544"use strict"; 24545 24546 24547var isOldIE = function isOldIE() { 24548 var memo; 24549 return function memorize() { 24550 if (typeof memo === 'undefined') { 24551 // Test for IE <= 9 as proposed by Browserhacks 24552 // @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805 24553 // Tests for existence of standard globals is to allow style-loader 24554 // to operate correctly into non-standard environments 24555 // @see https://github.com/webpack-contrib/style-loader/issues/177 24556 memo = Boolean(window && document && document.all && !window.atob); 24557 } 24558 24559 return memo; 24560 }; 24561}(); 24562 24563var getTarget = function getTarget() { 24564 var memo = {}; 24565 return function memorize(target) { 24566 if (typeof memo[target] === 'undefined') { 24567 var styleTarget = document.querySelector(target); // Special case to return head of iframe instead of iframe itself 24568 24569 if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) { 24570 try { 24571 // This will throw an exception if access to iframe is blocked 24572 // due to cross-origin restrictions 24573 styleTarget = styleTarget.contentDocument.head; 24574 } catch (e) { 24575 // istanbul ignore next 24576 styleTarget = null; 24577 } 24578 } 24579 24580 memo[target] = styleTarget; 24581 } 24582 24583 return memo[target]; 24584 }; 24585}(); 24586 24587var stylesInDom = []; 24588 24589function getIndexByIdentifier(identifier) { 24590 var result = -1; 24591 24592 for (var i = 0; i < stylesInDom.length; i++) { 24593 if (stylesInDom[i].identifier === identifier) { 24594 result = i; 24595 break; 24596 } 24597 } 24598 24599 return result; 24600} 24601 24602function modulesToDom(list, options) { 24603 var idCountMap = {}; 24604 var identifiers = []; 24605 24606 for (var i = 0; i < list.length; i++) { 24607 var item = list[i]; 24608 var id = options.base ? item[0] + options.base : item[0]; 24609 var count = idCountMap[id] || 0; 24610 var identifier = "".concat(id, " ").concat(count); 24611 idCountMap[id] = count + 1; 24612 var index = getIndexByIdentifier(identifier); 24613 var obj = { 24614 css: item[1], 24615 media: item[2], 24616 sourceMap: item[3] 24617 }; 24618 24619 if (index !== -1) { 24620 stylesInDom[index].references++; 24621 stylesInDom[index].updater(obj); 24622 } else { 24623 stylesInDom.push({ 24624 identifier: identifier, 24625 updater: addStyle(obj, options), 24626 references: 1 24627 }); 24628 } 24629 24630 identifiers.push(identifier); 24631 } 24632 24633 return identifiers; 24634} 24635 24636function insertStyleElement(options) { 24637 var style = document.createElement('style'); 24638 var attributes = options.attributes || {}; 24639 24640 if (typeof attributes.nonce === 'undefined') { 24641 var nonce = true ? __webpack_require__.nc : 0; 24642 24643 if (nonce) { 24644 attributes.nonce = nonce; 24645 } 24646 } 24647 24648 Object.keys(attributes).forEach(function (key) { 24649 style.setAttribute(key, attributes[key]); 24650 }); 24651 24652 if (typeof options.insert === 'function') { 24653 options.insert(style); 24654 } else { 24655 var target = getTarget(options.insert || 'head'); 24656 24657 if (!target) { 24658 throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid."); 24659 } 24660 24661 target.appendChild(style); 24662 } 24663 24664 return style; 24665} 24666 24667function removeStyleElement(style) { 24668 // istanbul ignore if 24669 if (style.parentNode === null) { 24670 return false; 24671 } 24672 24673 style.parentNode.removeChild(style); 24674} 24675/* istanbul ignore next */ 24676 24677 24678var replaceText = function replaceText() { 24679 var textStore = []; 24680 return function replace(index, replacement) { 24681 textStore[index] = replacement; 24682 return textStore.filter(Boolean).join('\n'); 24683 }; 24684}(); 24685 24686function applyToSingletonTag(style, index, remove, obj) { 24687 var css = remove ? '' : obj.media ? "@media ".concat(obj.media, " {").concat(obj.css, "}") : obj.css; // For old IE 24688 24689 /* istanbul ignore if */ 24690 24691 if (style.styleSheet) { 24692 style.styleSheet.cssText = replaceText(index, css); 24693 } else { 24694 var cssNode = document.createTextNode(css); 24695 var childNodes = style.childNodes; 24696 24697 if (childNodes[index]) { 24698 style.removeChild(childNodes[index]); 24699 } 24700 24701 if (childNodes.length) { 24702 style.insertBefore(cssNode, childNodes[index]); 24703 } else { 24704 style.appendChild(cssNode); 24705 } 24706 } 24707} 24708 24709function applyToTag(style, options, obj) { 24710 var css = obj.css; 24711 var media = obj.media; 24712 var sourceMap = obj.sourceMap; 24713 24714 if (media) { 24715 style.setAttribute('media', media); 24716 } else { 24717 style.removeAttribute('media'); 24718 } 24719 24720 if (sourceMap && typeof btoa !== 'undefined') { 24721 css += "\n/*# sourceMappingURL=data:application/json;base64,".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), " */"); 24722 } // For old IE 24723 24724 /* istanbul ignore if */ 24725 24726 24727 if (style.styleSheet) { 24728 style.styleSheet.cssText = css; 24729 } else { 24730 while (style.firstChild) { 24731 style.removeChild(style.firstChild); 24732 } 24733 24734 style.appendChild(document.createTextNode(css)); 24735 } 24736} 24737 24738var singleton = null; 24739var singletonCounter = 0; 24740 24741function addStyle(obj, options) { 24742 var style; 24743 var update; 24744 var remove; 24745 24746 if (options.singleton) { 24747 var styleIndex = singletonCounter++; 24748 style = singleton || (singleton = insertStyleElement(options)); 24749 update = applyToSingletonTag.bind(null, style, styleIndex, false); 24750 remove = applyToSingletonTag.bind(null, style, styleIndex, true); 24751 } else { 24752 style = insertStyleElement(options); 24753 update = applyToTag.bind(null, style, options); 24754 24755 remove = function remove() { 24756 removeStyleElement(style); 24757 }; 24758 } 24759 24760 update(obj); 24761 return function updateStyle(newObj) { 24762 if (newObj) { 24763 if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap) { 24764 return; 24765 } 24766 24767 update(obj = newObj); 24768 } else { 24769 remove(); 24770 } 24771 }; 24772} 24773 24774module.exports = function (list, options) { 24775 options = options || {}; // Force single-tag solution on IE6-9, which has a hard limit on the # of <style> 24776 // tags it will allow on a page 24777 24778 if (!options.singleton && typeof options.singleton !== 'boolean') { 24779 options.singleton = isOldIE(); 24780 } 24781 24782 list = list || []; 24783 var lastIdentifiers = modulesToDom(list, options); 24784 return function update(newList) { 24785 newList = newList || []; 24786 24787 if (Object.prototype.toString.call(newList) !== '[object Array]') { 24788 return; 24789 } 24790 24791 for (var i = 0; i < lastIdentifiers.length; i++) { 24792 var identifier = lastIdentifiers[i]; 24793 var index = getIndexByIdentifier(identifier); 24794 stylesInDom[index].references--; 24795 } 24796 24797 var newLastIdentifiers = modulesToDom(newList, options); 24798 24799 for (var _i = 0; _i < lastIdentifiers.length; _i++) { 24800 var _identifier = lastIdentifiers[_i]; 24801 24802 var _index = getIndexByIdentifier(_identifier); 24803 24804 if (stylesInDom[_index].references === 0) { 24805 stylesInDom[_index].updater(); 24806 24807 stylesInDom.splice(_index, 1); 24808 } 24809 } 24810 24811 lastIdentifiers = newLastIdentifiers; 24812 }; 24813}; 24814 24815/***/ }), 24816
vendor: 630 bytes, lines 24817-24838
24817/***/ "./node_modules/vue-loader/dist/exportHelper.js": 24818/*!******************************************************!*\ 24819 !*** ./node_modules/vue-loader/dist/exportHelper.js ***! 24820 \******************************************************/ 24821/***/ ((__unused_webpack_module, exports) => { 24822 24823"use strict"; 24824 24825Object.defineProperty(exports, "__esModule", ({ value: true })); 24826// runtime helper for setting properties on components 24827// in a tree-shakable way 24828exports["default"] = (sfc, props) => { 24829 const target = sfc.__vccOpts || sfc; 24830 for (const [key, val] of props) { 24831 target[key] = val; 24832 } 24833 return target; 24834}; 24835 24836 24837/***/ }), 24838
vendor: 24,549 bytes, lines 24839-25096
24839/***/ "./node_modules/vue/dist/vue.esm-bundler.js": 24840/*!**************************************************!*\ 24841 !*** ./node_modules/vue/dist/vue.esm-bundler.js ***! 24842 \**************************************************/ 24843/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 24844 24845"use strict"; 24846__webpack_require__.r(__webpack_exports__); 24847/* harmony export */ __webpack_require__.d(__webpack_exports__, { 24848/* harmony export */ BaseTransition: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.BaseTransition), 24849/* harmony export */ BaseTransitionPropsValidators: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.BaseTransitionPropsValidators), 24850/* harmony export */ Comment: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Comment), 24851/* harmony export */ DeprecationTypes: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.DeprecationTypes), 24852/* harmony export */ EffectScope: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.EffectScope), 24853/* harmony export */ ErrorCodes: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ErrorCodes), 24854/* harmony export */ ErrorTypeStrings: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ErrorTypeStrings), 24855/* harmony export */ Fragment: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Fragment), 24856/* harmony export */ KeepAlive: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.KeepAlive), 24857/* harmony export */ ReactiveEffect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect), 24858/* harmony export */ Static: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Static), 24859/* harmony export */ Suspense: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Suspense), 24860/* harmony export */ Teleport: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Teleport), 24861/* harmony export */ Text: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Text), 24862/* harmony export */ TrackOpTypes: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.TrackOpTypes), 24863/* harmony export */ Transition: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Transition), 24864/* harmony export */ TransitionGroup: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.TransitionGroup), 24865/* harmony export */ TriggerOpTypes: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.TriggerOpTypes), 24866/* harmony export */ VueElement: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.VueElement), 24867/* harmony export */ assertNumber: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.assertNumber), 24868/* harmony export */ callWithAsyncErrorHandling: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling), 24869/* harmony export */ callWithErrorHandling: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.callWithErrorHandling), 24870/* harmony export */ camelize: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.camelize), 24871/* harmony export */ capitalize: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.capitalize), 24872/* harmony export */ cloneVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.cloneVNode), 24873/* harmony export */ compatUtils: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.compatUtils), 24874/* harmony export */ compile: () => (/* binding */ compileToFunction), 24875/* harmony export */ computed: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.computed), 24876/* harmony export */ createApp: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createApp), 24877/* harmony export */ createBlock: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createBlock), 24878/* harmony export */ createCommentVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode), 24879/* harmony export */ createElementBlock: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createElementBlock), 24880/* harmony export */ createElementVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createElementVNode), 24881/* harmony export */ createHydrationRenderer: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer), 24882/* harmony export */ createPropsRestProxy: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createPropsRestProxy), 24883/* harmony export */ createRenderer: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createRenderer), 24884/* harmony export */ createSSRApp: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createSSRApp), 24885/* harmony export */ createSlots: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createSlots), 24886/* harmony export */ createStaticVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode), 24887/* harmony export */ createTextVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createTextVNode), 24888/* harmony export */ createVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createVNode), 24889/* harmony export */ customRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.customRef), 24890/* harmony export */ defineAsyncComponent: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineAsyncComponent), 24891/* harmony export */ defineComponent: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineComponent), 24892/* harmony export */ defineCustomElement: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineCustomElement), 24893/* harmony export */ defineEmits: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineEmits), 24894/* harmony export */ defineExpose: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineExpose), 24895/* harmony export */ defineModel: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineModel), 24896/* harmony export */ defineOptions: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineOptions), 24897/* harmony export */ defineProps: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineProps), 24898/* harmony export */ defineSSRCustomElement: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineSSRCustomElement), 24899/* harmony export */ defineSlots: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineSlots), 24900/* harmony export */ devtools: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.devtools), 24901/* harmony export */ effect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.effect), 24902/* harmony export */ effectScope: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.effectScope), 24903/* harmony export */ getCurrentInstance: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance), 24904/* harmony export */ getCurrentScope: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope), 24905/* harmony export */ getCurrentWatcher: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.getCurrentWatcher), 24906/* harmony export */ getTransitionRawChildren: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren), 24907/* harmony export */ guardReactiveProps: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.guardReactiveProps), 24908/* harmony export */ h: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.h), 24909/* harmony export */ handleError: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.handleError), 24910/* harmony export */ hasInjectionContext: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.hasInjectionContext), 24911/* harmony export */ hydrate: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.hydrate), 24912/* harmony export */ hydrateOnIdle: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.hydrateOnIdle), 24913/* harmony export */ hydrateOnInteraction: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.hydrateOnInteraction), 24914/* harmony export */ hydrateOnMediaQuery: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.hydrateOnMediaQuery), 24915/* harmony export */ hydrateOnVisible: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.hydrateOnVisible), 24916/* harmony export */ initCustomFormatter: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.initCustomFormatter), 24917/* harmony export */ initDirectivesForSSR: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.initDirectivesForSSR), 24918/* harmony export */ inject: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.inject), 24919/* harmony export */ isMemoSame: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isMemoSame), 24920/* harmony export */ isProxy: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isProxy), 24921/* harmony export */ isReactive: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isReactive), 24922/* harmony export */ isReadonly: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isReadonly), 24923/* harmony export */ isRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isRef), 24924/* harmony export */ isRuntimeOnly: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly), 24925/* harmony export */ isShallow: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isShallow), 24926/* harmony export */ isVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isVNode), 24927/* harmony export */ markRaw: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.markRaw), 24928/* harmony export */ mergeDefaults: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.mergeDefaults), 24929/* harmony export */ mergeModels: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.mergeModels), 24930/* harmony export */ mergeProps: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.mergeProps), 24931/* harmony export */ nextTick: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.nextTick), 24932/* harmony export */ normalizeClass: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.normalizeClass), 24933/* harmony export */ normalizeProps: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.normalizeProps), 24934/* harmony export */ normalizeStyle: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle), 24935/* harmony export */ onActivated: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onActivated), 24936/* harmony export */ onBeforeMount: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount), 24937/* harmony export */ onBeforeUnmount: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount), 24938/* harmony export */ onBeforeUpdate: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onBeforeUpdate), 24939/* harmony export */ onDeactivated: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onDeactivated), 24940/* harmony export */ onErrorCaptured: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onErrorCaptured), 24941/* harmony export */ onMounted: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onMounted), 24942/* harmony export */ onRenderTracked: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onRenderTracked), 24943/* harmony export */ onRenderTriggered: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onRenderTriggered), 24944/* harmony export */ onScopeDispose: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose), 24945/* harmony export */ onServerPrefetch: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onServerPrefetch), 24946/* harmony export */ onUnmounted: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onUnmounted), 24947/* harmony export */ onUpdated: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onUpdated), 24948/* harmony export */ onWatcherCleanup: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onWatcherCleanup), 24949/* harmony export */ openBlock: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.openBlock), 24950/* harmony export */ popScopeId: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.popScopeId), 24951/* harmony export */ provide: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.provide), 24952/* harmony export */ proxyRefs: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.proxyRefs), 24953/* harmony export */ pushScopeId: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.pushScopeId), 24954/* harmony export */ queuePostFlushCb: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.queuePostFlushCb), 24955/* harmony export */ reactive: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.reactive), 24956/* harmony export */ readonly: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.readonly), 24957/* harmony export */ ref: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ref), 24958/* harmony export */ registerRuntimeCompiler: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeCompiler), 24959/* harmony export */ render: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.render), 24960/* harmony export */ renderList: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.renderList), 24961/* harmony export */ renderSlot: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.renderSlot), 24962/* harmony export */ resolveComponent: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveComponent), 24963/* harmony export */ resolveDirective: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveDirective), 24964/* harmony export */ resolveDynamicComponent: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent), 24965/* harmony export */ resolveFilter: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveFilter), 24966/* harmony export */ resolveTransitionHooks: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks), 24967/* harmony export */ setBlockTracking: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.setBlockTracking), 24968/* harmony export */ setDevtoolsHook: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.setDevtoolsHook), 24969/* harmony export */ setTransitionHooks: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks), 24970/* harmony export */ shallowReactive: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.shallowReactive), 24971/* harmony export */ shallowReadonly: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly), 24972/* harmony export */ shallowRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.shallowRef), 24973/* harmony export */ ssrContextKey: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ssrContextKey), 24974/* harmony export */ ssrUtils: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ssrUtils), 24975/* harmony export */ stop: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.stop), 24976/* harmony export */ toDisplayString: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toDisplayString), 24977/* harmony export */ toHandlerKey: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey), 24978/* harmony export */ toHandlers: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toHandlers), 24979/* harmony export */ toRaw: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toRaw), 24980/* harmony export */ toRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toRef), 24981/* harmony export */ toRefs: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toRefs), 24982/* harmony export */ toValue: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toValue), 24983/* harmony export */ transformVNodeArgs: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.transformVNodeArgs), 24984/* harmony export */ triggerRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.triggerRef), 24985/* harmony export */ unref: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.unref), 24986/* harmony export */ useAttrs: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useAttrs), 24987/* harmony export */ useCssModule: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useCssModule), 24988/* harmony export */ useCssVars: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useCssVars), 24989/* harmony export */ useHost: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useHost), 24990/* harmony export */ useId: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useId), 24991/* harmony export */ useModel: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useModel), 24992/* harmony export */ useSSRContext: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useSSRContext), 24993/* harmony export */ useShadowRoot: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useShadowRoot), 24994/* harmony export */ useSlots: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useSlots), 24995/* harmony export */ useTemplateRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useTemplateRef), 24996/* harmony export */ useTransitionState: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useTransitionState), 24997/* harmony export */ vModelCheckbox: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelCheckbox), 24998/* harmony export */ vModelDynamic: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelDynamic), 24999/* harmony export */ vModelRadio: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelRadio), 25000/* harmony export */ vModelSelect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelSelect), 25001/* harmony export */ vModelText: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelText), 25002/* harmony export */ vShow: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vShow), 25003/* harmony export */ version: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.version), 25004/* harmony export */ warn: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.warn), 25005/* harmony export */ watch: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watch), 25006/* harmony export */ watchEffect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watchEffect), 25007/* harmony export */ watchPostEffect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watchPostEffect), 25008/* harmony export */ watchSyncEffect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watchSyncEffect), 25009/* harmony export */ withAsyncContext: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withAsyncContext), 25010/* harmony export */ withCtx: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withCtx), 25011/* harmony export */ withDefaults: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withDefaults), 25012/* harmony export */ withDirectives: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withDirectives), 25013/* harmony export */ withKeys: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withKeys), 25014/* harmony export */ withMemo: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withMemo), 25015/* harmony export */ withModifiers: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withModifiers), 25016/* harmony export */ withScopeId: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withScopeId) 25017/* harmony export */ }); 25018/* harmony import */ var _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/runtime-dom */ "./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js"); 25019/* harmony import */ var _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/runtime-dom */ "./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js"); 25020/* harmony import */ var _vue_compiler_dom__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @vue/compiler-dom */ "./node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js"); 25021/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 25022/** 25023* vue v3.5.13 25024* (c) 2018-present Yuxi (Evan) You and Vue contributors 25025* @license MIT 25026**/ 25027 25028 25029 25030 25031 25032 25033function initDev() { 25034 { 25035 (0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.initCustomFormatter)(); 25036 } 25037} 25038 25039if (true) { 25040 initDev(); 25041} 25042const compileCache = /* @__PURE__ */ Object.create(null); 25043function compileToFunction(template, options) { 25044 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_2__.isString)(template)) { 25045 if (template.nodeType) { 25046 template = template.innerHTML; 25047 } else { 25048 true && (0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.warn)(`invalid template option: `, template); 25049 return _vue_shared__WEBPACK_IMPORTED_MODULE_2__.NOOP; 25050 } 25051 } 25052 const key = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_2__.genCacheKey)(template, options); 25053 const cached = compileCache[key]; 25054 if (cached) { 25055 return cached; 25056 } 25057 if (template[0] === "#") { 25058 const el = document.querySelector(template); 25059 if ( true && !el) { 25060 (0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.warn)(`Template element not found or is empty: ${template}`); 25061 } 25062 template = el ? el.innerHTML : ``; 25063 } 25064 const opts = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_2__.extend)( 25065 { 25066 hoistStatic: true, 25067 onError: true ? onError : 0, 25068 onWarn: true ? (e) => onError(e, true) : 0 25069 }, 25070 options 25071 ); 25072 if (!opts.isCustomElement && typeof customElements !== "undefined") { 25073 opts.isCustomElement = (tag) => !!customElements.get(tag); 25074 } 25075 const { code } = (0,_vue_compiler_dom__WEBPACK_IMPORTED_MODULE_3__.compile)(template, opts); 25076 function onError(err, asWarning = false) { 25077 const message = asWarning ? err.message : `Template compilation error: ${err.message}`; 25078 const codeFrame = err.loc && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_2__.generateCodeFrame)( 25079 template, 25080 err.loc.start.offset, 25081 err.loc.end.offset 25082 ); 25083 (0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.warn)(codeFrame ? `${message} 25084${codeFrame}` : message); 25085 } 25086 const render = new Function("Vue", code)(_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__); 25087 render._rc = true; 25088 return compileCache[key] = render; 25089} 25090(0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.registerRuntimeCompiler)(compileToFunction); 25091 25092 25093 25094 25095/***/ }), 25096
vendor: 291,081 bytes, lines 25097-33373
25097/***/ "./node_modules/@vueuse/core/index.mjs": 25098/*!*********************************************!*\ 25099 !*** ./node_modules/@vueuse/core/index.mjs ***! 25100 \*********************************************/ 25101/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 25102 25103"use strict"; 25104__webpack_require__.r(__webpack_exports__); 25105/* harmony export */ __webpack_require__.d(__webpack_exports__, { 25106/* harmony export */ DefaultMagicKeysAliasMap: () => (/* binding */ DefaultMagicKeysAliasMap), 25107/* harmony export */ StorageSerializers: () => (/* binding */ StorageSerializers), 25108/* harmony export */ TransitionPresets: () => (/* binding */ TransitionPresets), 25109/* harmony export */ assert: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.assert), 25110/* harmony export */ asyncComputed: () => (/* binding */ computedAsync), 25111/* harmony export */ autoResetRef: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.autoResetRef), 25112/* harmony export */ breakpointsAntDesign: () => (/* binding */ breakpointsAntDesign), 25113/* harmony export */ breakpointsBootstrapV5: () => (/* binding */ breakpointsBootstrapV5), 25114/* harmony export */ breakpointsElement: () => (/* binding */ breakpointsElement), 25115/* harmony export */ breakpointsMasterCss: () => (/* binding */ breakpointsMasterCss), 25116/* harmony export */ breakpointsPrimeFlex: () => (/* binding */ breakpointsPrimeFlex), 25117/* harmony export */ breakpointsQuasar: () => (/* binding */ breakpointsQuasar), 25118/* harmony export */ breakpointsSematic: () => (/* binding */ breakpointsSematic), 25119/* harmony export */ breakpointsTailwind: () => (/* binding */ breakpointsTailwind), 25120/* harmony export */ breakpointsVuetify: () => (/* binding */ breakpointsVuetify), 25121/* harmony export */ breakpointsVuetifyV2: () => (/* binding */ breakpointsVuetifyV2), 25122/* harmony export */ breakpointsVuetifyV3: () => (/* binding */ breakpointsVuetifyV3), 25123/* harmony export */ bypassFilter: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.bypassFilter), 25124/* harmony export */ camelize: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.camelize), 25125/* harmony export */ clamp: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.clamp), 25126/* harmony export */ cloneFnJSON: () => (/* binding */ cloneFnJSON), 25127/* harmony export */ computedAsync: () => (/* binding */ computedAsync), 25128/* harmony export */ computedEager: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.computedEager), 25129/* harmony export */ computedInject: () => (/* binding */ computedInject), 25130/* harmony export */ computedWithControl: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.computedWithControl), 25131/* harmony export */ containsProp: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.containsProp), 25132/* harmony export */ controlledComputed: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.controlledComputed), 25133/* harmony export */ controlledRef: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.controlledRef), 25134/* harmony export */ createEventHook: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook), 25135/* harmony export */ createFetch: () => (/* binding */ createFetch), 25136/* harmony export */ createFilterWrapper: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createFilterWrapper), 25137/* harmony export */ createGlobalState: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createGlobalState), 25138/* harmony export */ createInjectionState: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createInjectionState), 25139/* harmony export */ createReactiveFn: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createReactiveFn), 25140/* harmony export */ createReusableTemplate: () => (/* binding */ createReusableTemplate), 25141/* harmony export */ createSharedComposable: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createSharedComposable), 25142/* harmony export */ createSingletonPromise: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createSingletonPromise), 25143/* harmony export */ createTemplatePromise: () => (/* binding */ createTemplatePromise), 25144/* harmony export */ createUnrefFn: () => (/* binding */ createUnrefFn), 25145/* harmony export */ customStorageEventName: () => (/* binding */ customStorageEventName), 25146/* harmony export */ debounceFilter: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.debounceFilter), 25147/* harmony export */ debouncedRef: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.debouncedRef), 25148/* harmony export */ debouncedWatch: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.debouncedWatch), 25149/* harmony export */ defaultDocument: () => (/* binding */ defaultDocument), 25150/* harmony export */ defaultLocation: () => (/* binding */ defaultLocation), 25151/* harmony export */ defaultNavigator: () => (/* binding */ defaultNavigator), 25152/* harmony export */ defaultWindow: () => (/* binding */ defaultWindow), 25153/* harmony export */ eagerComputed: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.eagerComputed), 25154/* harmony export */ executeTransition: () => (/* binding */ executeTransition), 25155/* harmony export */ extendRef: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.extendRef), 25156/* harmony export */ formatDate: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.formatDate), 25157/* harmony export */ formatTimeAgo: () => (/* binding */ formatTimeAgo), 25158/* harmony export */ get: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.get), 25159/* harmony export */ getLifeCycleTarget: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.getLifeCycleTarget), 25160/* harmony export */ getSSRHandler: () => (/* binding */ getSSRHandler), 25161/* harmony export */ hasOwn: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn), 25162/* harmony export */ hyphenate: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.hyphenate), 25163/* harmony export */ identity: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.identity), 25164/* harmony export */ ignorableWatch: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.ignorableWatch), 25165/* harmony export */ increaseWithUnit: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.increaseWithUnit), 25166/* harmony export */ injectLocal: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.injectLocal), 25167/* harmony export */ invoke: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.invoke), 25168/* harmony export */ isClient: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient), 25169/* harmony export */ isDef: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isDef), 25170/* harmony export */ isDefined: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isDefined), 25171/* harmony export */ isIOS: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isIOS), 25172/* harmony export */ isObject: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isObject), 25173/* harmony export */ isWorker: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isWorker), 25174/* harmony export */ makeDestructurable: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.makeDestructurable), 25175/* harmony export */ mapGamepadToXbox360Controller: () => (/* binding */ mapGamepadToXbox360Controller), 25176/* harmony export */ noop: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop), 25177/* harmony export */ normalizeDate: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.normalizeDate), 25178/* harmony export */ notNullish: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.notNullish), 25179/* harmony export */ now: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.now), 25180/* harmony export */ objectEntries: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.objectEntries), 25181/* harmony export */ objectOmit: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.objectOmit), 25182/* harmony export */ objectPick: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.objectPick), 25183/* harmony export */ onClickOutside: () => (/* binding */ onClickOutside), 25184/* harmony export */ onElementRemoval: () => (/* binding */ onElementRemoval), 25185/* harmony export */ onKeyDown: () => (/* binding */ onKeyDown), 25186/* harmony export */ onKeyPressed: () => (/* binding */ onKeyPressed), 25187/* harmony export */ onKeyStroke: () => (/* binding */ onKeyStroke), 25188/* harmony export */ onKeyUp: () => (/* binding */ onKeyUp), 25189/* harmony export */ onLongPress: () => (/* binding */ onLongPress), 25190/* harmony export */ onStartTyping: () => (/* binding */ onStartTyping), 25191/* harmony export */ pausableFilter: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pausableFilter), 25192/* harmony export */ pausableWatch: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pausableWatch), 25193/* harmony export */ promiseTimeout: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.promiseTimeout), 25194/* harmony export */ provideLocal: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.provideLocal), 25195/* harmony export */ provideSSRWidth: () => (/* binding */ provideSSRWidth), 25196/* harmony export */ pxValue: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pxValue), 25197/* harmony export */ rand: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.rand), 25198/* harmony export */ reactify: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.reactify), 25199/* harmony export */ reactifyObject: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.reactifyObject), 25200/* harmony export */ reactiveComputed: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.reactiveComputed), 25201/* harmony export */ reactiveOmit: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.reactiveOmit), 25202/* harmony export */ reactivePick: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.reactivePick), 25203/* harmony export */ refAutoReset: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.refAutoReset), 25204/* harmony export */ refDebounced: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.refDebounced), 25205/* harmony export */ refDefault: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.refDefault), 25206/* harmony export */ refThrottled: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.refThrottled), 25207/* harmony export */ refWithControl: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.refWithControl), 25208/* harmony export */ resolveRef: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.resolveRef), 25209/* harmony export */ resolveUnref: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.resolveUnref), 25210/* harmony export */ set: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.set), 25211/* harmony export */ setSSRHandler: () => (/* binding */ setSSRHandler), 25212/* harmony export */ syncRef: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.syncRef), 25213/* harmony export */ syncRefs: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.syncRefs), 25214/* harmony export */ templateRef: () => (/* binding */ templateRef), 25215/* harmony export */ throttleFilter: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.throttleFilter), 25216/* harmony export */ throttledRef: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.throttledRef), 25217/* harmony export */ throttledWatch: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.throttledWatch), 25218/* harmony export */ timestamp: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.timestamp), 25219/* harmony export */ toArray: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toArray), 25220/* harmony export */ toReactive: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toReactive), 25221/* harmony export */ toRef: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef), 25222/* harmony export */ toRefs: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRefs), 25223/* harmony export */ toValue: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toValue), 25224/* harmony export */ tryOnBeforeMount: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnBeforeMount), 25225/* harmony export */ tryOnBeforeUnmount: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnBeforeUnmount), 25226/* harmony export */ tryOnMounted: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted), 25227/* harmony export */ tryOnScopeDispose: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose), 25228/* harmony export */ tryOnUnmounted: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnUnmounted), 25229/* harmony export */ unrefElement: () => (/* binding */ unrefElement), 25230/* harmony export */ until: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.until), 25231/* harmony export */ useActiveElement: () => (/* binding */ useActiveElement), 25232/* harmony export */ useAnimate: () => (/* binding */ useAnimate), 25233/* harmony export */ useArrayDifference: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayDifference), 25234/* harmony export */ useArrayEvery: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayEvery), 25235/* harmony export */ useArrayFilter: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayFilter), 25236/* harmony export */ useArrayFind: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayFind), 25237/* harmony export */ useArrayFindIndex: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayFindIndex), 25238/* harmony export */ useArrayFindLast: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayFindLast), 25239/* harmony export */ useArrayIncludes: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayIncludes), 25240/* harmony export */ useArrayJoin: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayJoin), 25241/* harmony export */ useArrayMap: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayMap), 25242/* harmony export */ useArrayReduce: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayReduce), 25243/* harmony export */ useArraySome: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArraySome), 25244/* harmony export */ useArrayUnique: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useArrayUnique), 25245/* harmony export */ useAsyncQueue: () => (/* binding */ useAsyncQueue), 25246/* harmony export */ useAsyncState: () => (/* binding */ useAsyncState), 25247/* harmony export */ useBase64: () => (/* binding */ useBase64), 25248/* harmony export */ useBattery: () => (/* binding */ useBattery), 25249/* harmony export */ useBluetooth: () => (/* binding */ useBluetooth), 25250/* harmony export */ useBreakpoints: () => (/* binding */ useBreakpoints), 25251/* harmony export */ useBroadcastChannel: () => (/* binding */ useBroadcastChannel), 25252/* harmony export */ useBrowserLocation: () => (/* binding */ useBrowserLocation), 25253/* harmony export */ useCached: () => (/* binding */ useCached), 25254/* harmony export */ useClipboard: () => (/* binding */ useClipboard), 25255/* harmony export */ useClipboardItems: () => (/* binding */ useClipboardItems), 25256/* harmony export */ useCloned: () => (/* binding */ useCloned), 25257/* harmony export */ useColorMode: () => (/* binding */ useColorMode), 25258/* harmony export */ useConfirmDialog: () => (/* binding */ useConfirmDialog), 25259/* harmony export */ useCountdown: () => (/* binding */ useCountdown), 25260/* harmony export */ useCounter: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useCounter), 25261/* harmony export */ useCssVar: () => (/* binding */ useCssVar), 25262/* harmony export */ useCurrentElement: () => (/* binding */ useCurrentElement), 25263/* harmony export */ useCycleList: () => (/* binding */ useCycleList), 25264/* harmony export */ useDark: () => (/* binding */ useDark), 25265/* harmony export */ useDateFormat: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useDateFormat), 25266/* harmony export */ useDebounce: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useDebounce), 25267/* harmony export */ useDebounceFn: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useDebounceFn), 25268/* harmony export */ useDebouncedRefHistory: () => (/* binding */ useDebouncedRefHistory), 25269/* harmony export */ useDeviceMotion: () => (/* binding */ useDeviceMotion), 25270/* harmony export */ useDeviceOrientation: () => (/* binding */ useDeviceOrientation), 25271/* harmony export */ useDevicePixelRatio: () => (/* binding */ useDevicePixelRatio), 25272/* harmony export */ useDevicesList: () => (/* binding */ useDevicesList), 25273/* harmony export */ useDisplayMedia: () => (/* binding */ useDisplayMedia), 25274/* harmony export */ useDocumentVisibility: () => (/* binding */ useDocumentVisibility), 25275/* harmony export */ useDraggable: () => (/* binding */ useDraggable), 25276/* harmony export */ useDropZone: () => (/* binding */ useDropZone), 25277/* harmony export */ useElementBounding: () => (/* binding */ useElementBounding), 25278/* harmony export */ useElementByPoint: () => (/* binding */ useElementByPoint), 25279/* harmony export */ useElementHover: () => (/* binding */ useElementHover), 25280/* harmony export */ useElementSize: () => (/* binding */ useElementSize), 25281/* harmony export */ useElementVisibility: () => (/* binding */ useElementVisibility), 25282/* harmony export */ useEventBus: () => (/* binding */ useEventBus), 25283/* harmony export */ useEventListener: () => (/* binding */ useEventListener), 25284/* harmony export */ useEventSource: () => (/* binding */ useEventSource), 25285/* harmony export */ useEyeDropper: () => (/* binding */ useEyeDropper), 25286/* harmony export */ useFavicon: () => (/* binding */ useFavicon), 25287/* harmony export */ useFetch: () => (/* binding */ useFetch), 25288/* harmony export */ useFileDialog: () => (/* binding */ useFileDialog), 25289/* harmony export */ useFileSystemAccess: () => (/* binding */ useFileSystemAccess), 25290/* harmony export */ useFocus: () => (/* binding */ useFocus), 25291/* harmony export */ useFocusWithin: () => (/* binding */ useFocusWithin), 25292/* harmony export */ useFps: () => (/* binding */ useFps), 25293/* harmony export */ useFullscreen: () => (/* binding */ useFullscreen), 25294/* harmony export */ useGamepad: () => (/* binding */ useGamepad), 25295/* harmony export */ useGeolocation: () => (/* binding */ useGeolocation), 25296/* harmony export */ useIdle: () => (/* binding */ useIdle), 25297/* harmony export */ useImage: () => (/* binding */ useImage), 25298/* harmony export */ useInfiniteScroll: () => (/* binding */ useInfiniteScroll), 25299/* harmony export */ useIntersectionObserver: () => (/* binding */ useIntersectionObserver), 25300/* harmony export */ useInterval: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useInterval), 25301/* harmony export */ useIntervalFn: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useIntervalFn), 25302/* harmony export */ useKeyModifier: () => (/* binding */ useKeyModifier), 25303/* harmony export */ useLastChanged: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useLastChanged), 25304/* harmony export */ useLocalStorage: () => (/* binding */ useLocalStorage), 25305/* harmony export */ useMagicKeys: () => (/* binding */ useMagicKeys), 25306/* harmony export */ useManualRefHistory: () => (/* binding */ useManualRefHistory), 25307/* harmony export */ useMediaControls: () => (/* binding */ useMediaControls), 25308/* harmony export */ useMediaQuery: () => (/* binding */ useMediaQuery), 25309/* harmony export */ useMemoize: () => (/* binding */ useMemoize), 25310/* harmony export */ useMemory: () => (/* binding */ useMemory), 25311/* harmony export */ useMounted: () => (/* binding */ useMounted), 25312/* harmony export */ useMouse: () => (/* binding */ useMouse), 25313/* harmony export */ useMouseInElement: () => (/* binding */ useMouseInElement), 25314/* harmony export */ useMousePressed: () => (/* binding */ useMousePressed), 25315/* harmony export */ useMutationObserver: () => (/* binding */ useMutationObserver), 25316/* harmony export */ useNavigatorLanguage: () => (/* binding */ useNavigatorLanguage), 25317/* harmony export */ useNetwork: () => (/* binding */ useNetwork), 25318/* harmony export */ useNow: () => (/* binding */ useNow), 25319/* harmony export */ useObjectUrl: () => (/* binding */ useObjectUrl), 25320/* harmony export */ useOffsetPagination: () => (/* binding */ useOffsetPagination), 25321/* harmony export */ useOnline: () => (/* binding */ useOnline), 25322/* harmony export */ usePageLeave: () => (/* binding */ usePageLeave), 25323/* harmony export */ useParallax: () => (/* binding */ useParallax), 25324/* harmony export */ useParentElement: () => (/* binding */ useParentElement), 25325/* harmony export */ usePerformanceObserver: () => (/* binding */ usePerformanceObserver), 25326/* harmony export */ usePermission: () => (/* binding */ usePermission), 25327/* harmony export */ usePointer: () => (/* binding */ usePointer), 25328/* harmony export */ usePointerLock: () => (/* binding */ usePointerLock), 25329/* harmony export */ usePointerSwipe: () => (/* binding */ usePointerSwipe), 25330/* harmony export */ usePreferredColorScheme: () => (/* binding */ usePreferredColorScheme), 25331/* harmony export */ usePreferredContrast: () => (/* binding */ usePreferredContrast), 25332/* harmony export */ usePreferredDark: () => (/* binding */ usePreferredDark), 25333/* harmony export */ usePreferredLanguages: () => (/* binding */ usePreferredLanguages), 25334/* harmony export */ usePreferredReducedMotion: () => (/* binding */ usePreferredReducedMotion), 25335/* harmony export */ usePreferredReducedTransparency: () => (/* binding */ usePreferredReducedTransparency), 25336/* harmony export */ usePrevious: () => (/* binding */ usePrevious), 25337/* harmony export */ useRafFn: () => (/* binding */ useRafFn), 25338/* harmony export */ useRefHistory: () => (/* binding */ useRefHistory), 25339/* harmony export */ useResizeObserver: () => (/* binding */ useResizeObserver), 25340/* harmony export */ useSSRWidth: () => (/* binding */ useSSRWidth), 25341/* harmony export */ useScreenOrientation: () => (/* binding */ useScreenOrientation), 25342/* harmony export */ useScreenSafeArea: () => (/* binding */ useScreenSafeArea), 25343/* harmony export */ useScriptTag: () => (/* binding */ useScriptTag), 25344/* harmony export */ useScroll: () => (/* binding */ useScroll), 25345/* harmony export */ useScrollLock: () => (/* binding */ useScrollLock), 25346/* harmony export */ useSessionStorage: () => (/* binding */ useSessionStorage), 25347/* harmony export */ useShare: () => (/* binding */ useShare), 25348/* harmony export */ useSorted: () => (/* binding */ useSorted), 25349/* harmony export */ useSpeechRecognition: () => (/* binding */ useSpeechRecognition), 25350/* harmony export */ useSpeechSynthesis: () => (/* binding */ useSpeechSynthesis), 25351/* harmony export */ useStepper: () => (/* binding */ useStepper), 25352/* harmony export */ useStorage: () => (/* binding */ useStorage), 25353/* harmony export */ useStorageAsync: () => (/* binding */ useStorageAsync), 25354/* harmony export */ useStyleTag: () => (/* binding */ useStyleTag), 25355/* harmony export */ useSupported: () => (/* binding */ useSupported), 25356/* harmony export */ useSwipe: () => (/* binding */ useSwipe), 25357/* harmony export */ useTemplateRefsList: () => (/* binding */ useTemplateRefsList), 25358/* harmony export */ useTextDirection: () => (/* binding */ useTextDirection), 25359/* harmony export */ useTextSelection: () => (/* binding */ useTextSelection), 25360/* harmony export */ useTextareaAutosize: () => (/* binding */ useTextareaAutosize), 25361/* harmony export */ useThrottle: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useThrottle), 25362/* harmony export */ useThrottleFn: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useThrottleFn), 25363/* harmony export */ useThrottledRefHistory: () => (/* binding */ useThrottledRefHistory), 25364/* harmony export */ useTimeAgo: () => (/* binding */ useTimeAgo), 25365/* harmony export */ useTimeout: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useTimeout), 25366/* harmony export */ useTimeoutFn: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useTimeoutFn), 25367/* harmony export */ useTimeoutPoll: () => (/* binding */ useTimeoutPoll), 25368/* harmony export */ useTimestamp: () => (/* binding */ useTimestamp), 25369/* harmony export */ useTitle: () => (/* binding */ useTitle), 25370/* harmony export */ useToNumber: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useToNumber), 25371/* harmony export */ useToString: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useToString), 25372/* harmony export */ useToggle: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useToggle), 25373/* harmony export */ useTransition: () => (/* binding */ useTransition), 25374/* harmony export */ useUrlSearchParams: () => (/* binding */ useUrlSearchParams), 25375/* harmony export */ useUserMedia: () => (/* binding */ useUserMedia), 25376/* harmony export */ useVModel: () => (/* binding */ useVModel), 25377/* harmony export */ useVModels: () => (/* binding */ useVModels), 25378/* harmony export */ useVibrate: () => (/* binding */ useVibrate), 25379/* harmony export */ useVirtualList: () => (/* binding */ useVirtualList), 25380/* harmony export */ useWakeLock: () => (/* binding */ useWakeLock), 25381/* harmony export */ useWebNotification: () => (/* binding */ useWebNotification), 25382/* harmony export */ useWebSocket: () => (/* binding */ useWebSocket), 25383/* harmony export */ useWebWorker: () => (/* binding */ useWebWorker), 25384/* harmony export */ useWebWorkerFn: () => (/* binding */ useWebWorkerFn), 25385/* harmony export */ useWindowFocus: () => (/* binding */ useWindowFocus), 25386/* harmony export */ useWindowScroll: () => (/* binding */ useWindowScroll), 25387/* harmony export */ useWindowSize: () => (/* binding */ useWindowSize), 25388/* harmony export */ watchArray: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchArray), 25389/* harmony export */ watchAtMost: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchAtMost), 25390/* harmony export */ watchDebounced: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchDebounced), 25391/* harmony export */ watchDeep: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchDeep), 25392/* harmony export */ watchIgnorable: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchIgnorable), 25393/* harmony export */ watchImmediate: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchImmediate), 25394/* harmony export */ watchOnce: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchOnce), 25395/* harmony export */ watchPausable: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchPausable), 25396/* harmony export */ watchThrottled: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchThrottled), 25397/* harmony export */ watchTriggerable: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchTriggerable), 25398/* harmony export */ watchWithFilter: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchWithFilter), 25399/* harmony export */ whenever: () => (/* reexport safe */ _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.whenever) 25400/* harmony export */ }); 25401/* harmony import */ var _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vueuse/shared */ "./node_modules/@vueuse/shared/index.mjs"); 25402/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.esm-bundler.js"); 25403 25404 25405 25406 25407function computedAsync(evaluationCallback, initialState, optionsOrRef) { 25408 let options; 25409 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.isRef)(optionsOrRef)) { 25410 options = { 25411 evaluating: optionsOrRef 25412 }; 25413 } else { 25414 options = optionsOrRef || {}; 25415 } 25416 const { 25417 lazy = false, 25418 evaluating = undefined, 25419 shallow = true, 25420 onError = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop 25421 } = options; 25422 const started = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(!lazy); 25423 const current = shallow ? (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(initialState) : (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialState); 25424 let counter = 0; 25425 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watchEffect)(async (onInvalidate) => { 25426 if (!started.value) 25427 return; 25428 counter++; 25429 const counterAtBeginning = counter; 25430 let hasFinished = false; 25431 if (evaluating) { 25432 Promise.resolve().then(() => { 25433 evaluating.value = true; 25434 }); 25435 } 25436 try { 25437 const result = await evaluationCallback((cancelCallback) => { 25438 onInvalidate(() => { 25439 if (evaluating) 25440 evaluating.value = false; 25441 if (!hasFinished) 25442 cancelCallback(); 25443 }); 25444 }); 25445 if (counterAtBeginning === counter) 25446 current.value = result; 25447 } catch (e) { 25448 onError(e); 25449 } finally { 25450 if (evaluating && counterAtBeginning === counter) 25451 evaluating.value = false; 25452 hasFinished = true; 25453 } 25454 }); 25455 if (lazy) { 25456 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 25457 started.value = true; 25458 return current.value; 25459 }); 25460 } else { 25461 return current; 25462 } 25463} 25464 25465function computedInject(key, options, defaultSource, treatDefaultAsFactory) { 25466 let source = (0,vue__WEBPACK_IMPORTED_MODULE_1__.inject)(key); 25467 if (defaultSource) 25468 source = (0,vue__WEBPACK_IMPORTED_MODULE_1__.inject)(key, defaultSource); 25469 if (treatDefaultAsFactory) 25470 source = (0,vue__WEBPACK_IMPORTED_MODULE_1__.inject)(key, defaultSource, treatDefaultAsFactory); 25471 if (typeof options === "function") { 25472 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)((ctx) => options(source, ctx)); 25473 } else { 25474 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 25475 get: (ctx) => options.get(source, ctx), 25476 set: options.set 25477 }); 25478 } 25479} 25480 25481function createReusableTemplate(options = {}) { 25482 const { 25483 inheritAttrs = true 25484 } = options; 25485 const render = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(); 25486 const define = /* #__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_1__.defineComponent)({ 25487 setup(_, { slots }) { 25488 return () => { 25489 render.value = slots.default; 25490 }; 25491 } 25492 }); 25493 const reuse = /* #__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_1__.defineComponent)({ 25494 inheritAttrs, 25495 setup(_, { attrs, slots }) { 25496 return () => { 25497 var _a; 25498 if (!render.value && "development" !== "production") 25499 throw new Error("[VueUse] Failed to find the definition of reusable template"); 25500 const vnode = (_a = render.value) == null ? undefined : _a.call(render, { ...keysToCamelKebabCase(attrs), $slots: slots }); 25501 return inheritAttrs && (vnode == null ? undefined : vnode.length) === 1 ? vnode[0] : vnode; 25502 }; 25503 } 25504 }); 25505 return (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.makeDestructurable)( 25506 { define, reuse }, 25507 [define, reuse] 25508 ); 25509} 25510function keysToCamelKebabCase(obj) { 25511 const newObj = {}; 25512 for (const key in obj) 25513 newObj[(0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(key)] = obj[key]; 25514 return newObj; 25515} 25516 25517function createTemplatePromise(options = {}) { 25518 let index = 0; 25519 const instances = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)([]); 25520 function create(...args) { 25521 const props = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowReactive)({ 25522 key: index++, 25523 args, 25524 promise: undefined, 25525 resolve: () => { 25526 }, 25527 reject: () => { 25528 }, 25529 isResolving: false, 25530 options 25531 }); 25532 instances.value.push(props); 25533 props.promise = new Promise((_resolve, _reject) => { 25534 props.resolve = (v) => { 25535 props.isResolving = true; 25536 return _resolve(v); 25537 }; 25538 props.reject = _reject; 25539 }).finally(() => { 25540 props.promise = undefined; 25541 const index2 = instances.value.indexOf(props); 25542 if (index2 !== -1) 25543 instances.value.splice(index2, 1); 25544 }); 25545 return props.promise; 25546 } 25547 function start(...args) { 25548 if (options.singleton && instances.value.length > 0) 25549 return instances.value[0].promise; 25550 return create(...args); 25551 } 25552 const component = /* #__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_1__.defineComponent)((_, { slots }) => { 25553 const renderList = () => instances.value.map((props) => { 25554 var _a; 25555 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.h)(vue__WEBPACK_IMPORTED_MODULE_1__.Fragment, { key: props.key }, (_a = slots.default) == null ? undefined : _a.call(slots, props)); 25556 }); 25557 if (options.transition) 25558 return () => (0,vue__WEBPACK_IMPORTED_MODULE_1__.h)(vue__WEBPACK_IMPORTED_MODULE_1__.TransitionGroup, options.transition, renderList); 25559 return renderList; 25560 }); 25561 component.start = start; 25562 return component; 25563} 25564 25565function createUnrefFn(fn) { 25566 return function(...args) { 25567 return fn.apply(this, args.map((i) => (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(i))); 25568 }; 25569} 25570 25571const defaultWindow = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient ? window : undefined; 25572const defaultDocument = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient ? window.document : undefined; 25573const defaultNavigator = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient ? window.navigator : undefined; 25574const defaultLocation = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient ? window.location : undefined; 25575 25576function unrefElement(elRef) { 25577 var _a; 25578 const plain = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(elRef); 25579 return (_a = plain == null ? undefined : plain.$el) != null ? _a : plain; 25580} 25581 25582function useEventListener(...args) { 25583 const cleanups = []; 25584 const cleanup = () => { 25585 cleanups.forEach((fn) => fn()); 25586 cleanups.length = 0; 25587 }; 25588 const register = (el, event, listener, options) => { 25589 el.addEventListener(event, listener, options); 25590 return () => el.removeEventListener(event, listener, options); 25591 }; 25592 const firstParamTargets = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 25593 const test = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(args[0])).filter((e) => e != null); 25594 return test.every((e) => typeof e !== "string") ? test : undefined; 25595 }); 25596 const stopWatch = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchImmediate)( 25597 () => { 25598 var _a, _b; 25599 return [ 25600 (_b = (_a = firstParamTargets.value) == null ? undefined : _a.map((e) => unrefElement(e))) != null ? _b : [defaultWindow].filter((e) => e != null), 25601 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(firstParamTargets.value ? args[1] : args[0])), 25602 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)((0,vue__WEBPACK_IMPORTED_MODULE_1__.unref)(firstParamTargets.value ? args[2] : args[1])), 25603 // @ts-expect-error - TypeScript gets the correct types, but somehow still complains 25604 (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(firstParamTargets.value ? args[3] : args[2]) 25605 ]; 25606 }, 25607 ([raw_targets, raw_events, raw_listeners, raw_options]) => { 25608 cleanup(); 25609 if (!(raw_targets == null ? undefined : raw_targets.length) || !(raw_events == null ? undefined : raw_events.length) || !(raw_listeners == null ? undefined : raw_listeners.length)) 25610 return; 25611 const optionsClone = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(raw_options) ? { ...raw_options } : raw_options; 25612 cleanups.push( 25613 ...raw_targets.flatMap( 25614 (el) => raw_events.flatMap( 25615 (event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone)) 25616 ) 25617 ) 25618 ); 25619 }, 25620 { flush: "post" } 25621 ); 25622 const stop = () => { 25623 stopWatch(); 25624 cleanup(); 25625 }; 25626 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(cleanup); 25627 return stop; 25628} 25629 25630let _iOSWorkaround = false; 25631function onClickOutside(target, handler, options = {}) { 25632 const { window = defaultWindow, ignore = [], capture = true, detectIframe = false } = options; 25633 if (!window) 25634 return _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop; 25635 if (_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isIOS && !_iOSWorkaround) { 25636 _iOSWorkaround = true; 25637 const listenerOptions = { passive: true }; 25638 Array.from(window.document.body.children).forEach((el) => useEventListener(el, "click", _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, listenerOptions)); 25639 useEventListener(window.document.documentElement, "click", _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, listenerOptions); 25640 } 25641 let shouldListen = true; 25642 const shouldIgnore = (event) => { 25643 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(ignore).some((target2) => { 25644 if (typeof target2 === "string") { 25645 return Array.from(window.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el)); 25646 } else { 25647 const el = unrefElement(target2); 25648 return el && (event.target === el || event.composedPath().includes(el)); 25649 } 25650 }); 25651 }; 25652 function hasMultipleRoots(target2) { 25653 const vm = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target2); 25654 return vm && vm.$.subTree.shapeFlag === 16; 25655 } 25656 function checkMultipleRoots(target2, event) { 25657 const vm = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target2); 25658 const children = vm.$.subTree && vm.$.subTree.children; 25659 if (children == null || !Array.isArray(children)) 25660 return false; 25661 return children.some((child) => child.el === event.target || event.composedPath().includes(child.el)); 25662 } 25663 const listener = (event) => { 25664 const el = unrefElement(target); 25665 if (event.target == null) 25666 return; 25667 if (!(el instanceof Element) && hasMultipleRoots(target) && checkMultipleRoots(target, event)) 25668 return; 25669 if (!el || el === event.target || event.composedPath().includes(el)) 25670 return; 25671 if (event.detail === 0) 25672 shouldListen = !shouldIgnore(event); 25673 if (!shouldListen) { 25674 shouldListen = true; 25675 return; 25676 } 25677 handler(event); 25678 }; 25679 let isProcessingClick = false; 25680 const cleanup = [ 25681 useEventListener(window, "click", (event) => { 25682 if (!isProcessingClick) { 25683 isProcessingClick = true; 25684 setTimeout(() => { 25685 isProcessingClick = false; 25686 }, 0); 25687 listener(event); 25688 } 25689 }, { passive: true, capture }), 25690 useEventListener(window, "pointerdown", (e) => { 25691 const el = unrefElement(target); 25692 shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el)); 25693 }, { passive: true }), 25694 detectIframe && useEventListener(window, "blur", (event) => { 25695 setTimeout(() => { 25696 var _a; 25697 const el = unrefElement(target); 25698 if (((_a = window.document.activeElement) == null ? undefined : _a.tagName) === "IFRAME" && !(el == null ? undefined : el.contains(window.document.activeElement))) { 25699 handler(event); 25700 } 25701 }, 0); 25702 }, { passive: true }) 25703 ].filter(Boolean); 25704 const stop = () => cleanup.forEach((fn) => fn()); 25705 return stop; 25706} 25707 25708function useMounted() { 25709 const isMounted = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 25710 const instance = (0,vue__WEBPACK_IMPORTED_MODULE_1__.getCurrentInstance)(); 25711 if (instance) { 25712 (0,vue__WEBPACK_IMPORTED_MODULE_1__.onMounted)(() => { 25713 isMounted.value = true; 25714 }, instance); 25715 } 25716 return isMounted; 25717} 25718 25719function useSupported(callback) { 25720 const isMounted = useMounted(); 25721 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 25722 isMounted.value; 25723 return Boolean(callback()); 25724 }); 25725} 25726 25727function useMutationObserver(target, callback, options = {}) { 25728 const { window = defaultWindow, ...mutationOptions } = options; 25729 let observer; 25730 const isSupported = useSupported(() => window && "MutationObserver" in window); 25731 const cleanup = () => { 25732 if (observer) { 25733 observer.disconnect(); 25734 observer = undefined; 25735 } 25736 }; 25737 const targets = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 25738 const value = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 25739 const items = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(value).map(unrefElement).filter(_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.notNullish); 25740 return new Set(items); 25741 }); 25742 const stopWatch = (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 25743 () => targets.value, 25744 (targets2) => { 25745 cleanup(); 25746 if (isSupported.value && targets2.size) { 25747 observer = new MutationObserver(callback); 25748 targets2.forEach((el) => observer.observe(el, mutationOptions)); 25749 } 25750 }, 25751 { immediate: true, flush: "post" } 25752 ); 25753 const takeRecords = () => { 25754 return observer == null ? undefined : observer.takeRecords(); 25755 }; 25756 const stop = () => { 25757 stopWatch(); 25758 cleanup(); 25759 }; 25760 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(stop); 25761 return { 25762 isSupported, 25763 stop, 25764 takeRecords 25765 }; 25766} 25767 25768function onElementRemoval(target, callback, options = {}) { 25769 const { 25770 window = defaultWindow, 25771 document = window == null ? undefined : window.document, 25772 flush = "sync" 25773 } = options; 25774 if (!window || !document) 25775 return _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop; 25776 let stopFn; 25777 const cleanupAndUpdate = (fn) => { 25778 stopFn == null ? undefined : stopFn(); 25779 stopFn = fn; 25780 }; 25781 const stopWatch = (0,vue__WEBPACK_IMPORTED_MODULE_1__.watchEffect)(() => { 25782 const el = unrefElement(target); 25783 if (el) { 25784 const { stop } = useMutationObserver( 25785 document, 25786 (mutationsList) => { 25787 const targetRemoved = mutationsList.map((mutation) => [...mutation.removedNodes]).flat().some((node) => node === el || node.contains(el)); 25788 if (targetRemoved) { 25789 callback(mutationsList); 25790 } 25791 }, 25792 { 25793 window, 25794 childList: true, 25795 subtree: true 25796 } 25797 ); 25798 cleanupAndUpdate(stop); 25799 } 25800 }, { flush }); 25801 const stopHandle = () => { 25802 stopWatch(); 25803 cleanupAndUpdate(); 25804 }; 25805 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(stopHandle); 25806 return stopHandle; 25807} 25808 25809function createKeyPredicate(keyFilter) { 25810 if (typeof keyFilter === "function") 25811 return keyFilter; 25812 else if (typeof keyFilter === "string") 25813 return (event) => event.key === keyFilter; 25814 else if (Array.isArray(keyFilter)) 25815 return (event) => keyFilter.includes(event.key); 25816 return () => true; 25817} 25818function onKeyStroke(...args) { 25819 let key; 25820 let handler; 25821 let options = {}; 25822 if (args.length === 3) { 25823 key = args[0]; 25824 handler = args[1]; 25825 options = args[2]; 25826 } else if (args.length === 2) { 25827 if (typeof args[1] === "object") { 25828 key = true; 25829 handler = args[0]; 25830 options = args[1]; 25831 } else { 25832 key = args[0]; 25833 handler = args[1]; 25834 } 25835 } else { 25836 key = true; 25837 handler = args[0]; 25838 } 25839 const { 25840 target = defaultWindow, 25841 eventName = "keydown", 25842 passive = false, 25843 dedupe = false 25844 } = options; 25845 const predicate = createKeyPredicate(key); 25846 const listener = (e) => { 25847 if (e.repeat && (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(dedupe)) 25848 return; 25849 if (predicate(e)) 25850 handler(e); 25851 }; 25852 return useEventListener(target, eventName, listener, passive); 25853} 25854function onKeyDown(key, handler, options = {}) { 25855 return onKeyStroke(key, handler, { ...options, eventName: "keydown" }); 25856} 25857function onKeyPressed(key, handler, options = {}) { 25858 return onKeyStroke(key, handler, { ...options, eventName: "keypress" }); 25859} 25860function onKeyUp(key, handler, options = {}) { 25861 return onKeyStroke(key, handler, { ...options, eventName: "keyup" }); 25862} 25863 25864const DEFAULT_DELAY = 500; 25865const DEFAULT_THRESHOLD = 10; 25866function onLongPress(target, handler, options) { 25867 var _a, _b; 25868 const elementRef = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => unrefElement(target)); 25869 let timeout; 25870 let posStart; 25871 let startTimestamp; 25872 let hasLongPressed = false; 25873 function clear() { 25874 if (timeout) { 25875 clearTimeout(timeout); 25876 timeout = undefined; 25877 } 25878 posStart = undefined; 25879 startTimestamp = undefined; 25880 hasLongPressed = false; 25881 } 25882 function onRelease(ev) { 25883 var _a2, _b2, _c; 25884 const [_startTimestamp, _posStart, _hasLongPressed] = [startTimestamp, posStart, hasLongPressed]; 25885 clear(); 25886 if (!(options == null ? undefined : options.onMouseUp) || !_posStart || !_startTimestamp) 25887 return; 25888 if (((_a2 = options == null ? undefined : options.modifiers) == null ? undefined : _a2.self) && ev.target !== elementRef.value) 25889 return; 25890 if ((_b2 = options == null ? undefined : options.modifiers) == null ? undefined : _b2.prevent) 25891 ev.preventDefault(); 25892 if ((_c = options == null ? undefined : options.modifiers) == null ? undefined : _c.stop) 25893 ev.stopPropagation(); 25894 const dx = ev.x - _posStart.x; 25895 const dy = ev.y - _posStart.y; 25896 const distance = Math.sqrt(dx * dx + dy * dy); 25897 options.onMouseUp(ev.timeStamp - _startTimestamp, distance, _hasLongPressed); 25898 } 25899 function onDown(ev) { 25900 var _a2, _b2, _c, _d; 25901 if (((_a2 = options == null ? undefined : options.modifiers) == null ? undefined : _a2.self) && ev.target !== elementRef.value) 25902 return; 25903 clear(); 25904 if ((_b2 = options == null ? undefined : options.modifiers) == null ? undefined : _b2.prevent) 25905 ev.preventDefault(); 25906 if ((_c = options == null ? undefined : options.modifiers) == null ? undefined : _c.stop) 25907 ev.stopPropagation(); 25908 posStart = { 25909 x: ev.x, 25910 y: ev.y 25911 }; 25912 startTimestamp = ev.timeStamp; 25913 timeout = setTimeout( 25914 () => { 25915 hasLongPressed = true; 25916 handler(ev); 25917 }, 25918 (_d = options == null ? undefined : options.delay) != null ? _d : DEFAULT_DELAY 25919 ); 25920 } 25921 function onMove(ev) { 25922 var _a2, _b2, _c, _d; 25923 if (((_a2 = options == null ? undefined : options.modifiers) == null ? undefined : _a2.self) && ev.target !== elementRef.value) 25924 return; 25925 if (!posStart || (options == null ? undefined : options.distanceThreshold) === false) 25926 return; 25927 if ((_b2 = options == null ? undefined : options.modifiers) == null ? undefined : _b2.prevent) 25928 ev.preventDefault(); 25929 if ((_c = options == null ? undefined : options.modifiers) == null ? undefined : _c.stop) 25930 ev.stopPropagation(); 25931 const dx = ev.x - posStart.x; 25932 const dy = ev.y - posStart.y; 25933 const distance = Math.sqrt(dx * dx + dy * dy); 25934 if (distance >= ((_d = options == null ? undefined : options.distanceThreshold) != null ? _d : DEFAULT_THRESHOLD)) 25935 clear(); 25936 } 25937 const listenerOptions = { 25938 capture: (_a = options == null ? undefined : options.modifiers) == null ? undefined : _a.capture, 25939 once: (_b = options == null ? undefined : options.modifiers) == null ? undefined : _b.once 25940 }; 25941 const cleanup = [ 25942 useEventListener(elementRef, "pointerdown", onDown, listenerOptions), 25943 useEventListener(elementRef, "pointermove", onMove, listenerOptions), 25944 useEventListener(elementRef, ["pointerup", "pointerleave"], onRelease, listenerOptions) 25945 ]; 25946 const stop = () => cleanup.forEach((fn) => fn()); 25947 return stop; 25948} 25949 25950function isFocusedElementEditable() { 25951 const { activeElement, body } = document; 25952 if (!activeElement) 25953 return false; 25954 if (activeElement === body) 25955 return false; 25956 switch (activeElement.tagName) { 25957 case "INPUT": 25958 case "TEXTAREA": 25959 return true; 25960 } 25961 return activeElement.hasAttribute("contenteditable"); 25962} 25963function isTypedCharValid({ 25964 keyCode, 25965 metaKey, 25966 ctrlKey, 25967 altKey 25968}) { 25969 if (metaKey || ctrlKey || altKey) 25970 return false; 25971 if (keyCode >= 48 && keyCode <= 57) 25972 return true; 25973 if (keyCode >= 65 && keyCode <= 90) 25974 return true; 25975 if (keyCode >= 97 && keyCode <= 122) 25976 return true; 25977 return false; 25978} 25979function onStartTyping(callback, options = {}) { 25980 const { document: document2 = defaultDocument } = options; 25981 const keydown = (event) => { 25982 if (!isFocusedElementEditable() && isTypedCharValid(event)) { 25983 callback(event); 25984 } 25985 }; 25986 if (document2) 25987 useEventListener(document2, "keydown", keydown, { passive: true }); 25988} 25989 25990function templateRef(key, initialValue = null) { 25991 const instance = (0,vue__WEBPACK_IMPORTED_MODULE_1__.getCurrentInstance)(); 25992 let _trigger = () => { 25993 }; 25994 const element = (0,vue__WEBPACK_IMPORTED_MODULE_1__.customRef)((track, trigger) => { 25995 _trigger = trigger; 25996 return { 25997 get() { 25998 var _a, _b; 25999 track(); 26000 return (_b = (_a = instance == null ? undefined : instance.proxy) == null ? undefined : _a.$refs[key]) != null ? _b : initialValue; 26001 }, 26002 set() { 26003 } 26004 }; 26005 }); 26006 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(_trigger); 26007 (0,vue__WEBPACK_IMPORTED_MODULE_1__.onUpdated)(_trigger); 26008 return element; 26009} 26010 26011function useActiveElement(options = {}) { 26012 var _a; 26013 const { 26014 window = defaultWindow, 26015 deep = true, 26016 triggerOnRemoval = false 26017 } = options; 26018 const document = (_a = options.document) != null ? _a : window == null ? undefined : window.document; 26019 const getDeepActiveElement = () => { 26020 var _a2; 26021 let element = document == null ? undefined : document.activeElement; 26022 if (deep) { 26023 while (element == null ? undefined : element.shadowRoot) 26024 element = (_a2 = element == null ? undefined : element.shadowRoot) == null ? undefined : _a2.activeElement; 26025 } 26026 return element; 26027 }; 26028 const activeElement = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 26029 const trigger = () => { 26030 activeElement.value = getDeepActiveElement(); 26031 }; 26032 if (window) { 26033 const listenerOptions = { 26034 capture: true, 26035 passive: true 26036 }; 26037 useEventListener( 26038 window, 26039 "blur", 26040 (event) => { 26041 if (event.relatedTarget !== null) 26042 return; 26043 trigger(); 26044 }, 26045 listenerOptions 26046 ); 26047 useEventListener( 26048 window, 26049 "focus", 26050 trigger, 26051 listenerOptions 26052 ); 26053 } 26054 if (triggerOnRemoval) { 26055 onElementRemoval(activeElement, trigger, { document }); 26056 } 26057 trigger(); 26058 return activeElement; 26059} 26060 26061function useRafFn(fn, options = {}) { 26062 const { 26063 immediate = true, 26064 fpsLimit = undefined, 26065 window = defaultWindow 26066 } = options; 26067 const isActive = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 26068 const intervalLimit = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 26069 return fpsLimit ? 1e3 / (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(fpsLimit) : null; 26070 }); 26071 let previousFrameTimestamp = 0; 26072 let rafId = null; 26073 function loop(timestamp) { 26074 if (!isActive.value || !window) 26075 return; 26076 if (!previousFrameTimestamp) 26077 previousFrameTimestamp = timestamp; 26078 const delta = timestamp - previousFrameTimestamp; 26079 if (intervalLimit.value && delta < intervalLimit.value) { 26080 rafId = window.requestAnimationFrame(loop); 26081 return; 26082 } 26083 previousFrameTimestamp = timestamp; 26084 fn({ delta, timestamp }); 26085 rafId = window.requestAnimationFrame(loop); 26086 } 26087 function resume() { 26088 if (!isActive.value && window) { 26089 isActive.value = true; 26090 previousFrameTimestamp = 0; 26091 rafId = window.requestAnimationFrame(loop); 26092 } 26093 } 26094 function pause() { 26095 isActive.value = false; 26096 if (rafId != null && window) { 26097 window.cancelAnimationFrame(rafId); 26098 rafId = null; 26099 } 26100 } 26101 if (immediate) 26102 resume(); 26103 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(pause); 26104 return { 26105 isActive: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(isActive), 26106 pause, 26107 resume 26108 }; 26109} 26110 26111function useAnimate(target, keyframes, options) { 26112 let config; 26113 let animateOptions; 26114 if ((0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(options)) { 26115 config = options; 26116 animateOptions = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.objectOmit)(options, ["window", "immediate", "commitStyles", "persist", "onReady", "onError"]); 26117 } else { 26118 config = { duration: options }; 26119 animateOptions = options; 26120 } 26121 const { 26122 window = defaultWindow, 26123 immediate = true, 26124 commitStyles, 26125 persist, 26126 playbackRate: _playbackRate = 1, 26127 onReady, 26128 onError = (e) => { 26129 console.error(e); 26130 } 26131 } = config; 26132 const isSupported = useSupported(() => window && HTMLElement && "animate" in HTMLElement.prototype); 26133 const animate = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(undefined); 26134 const store = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowReactive)({ 26135 startTime: null, 26136 currentTime: null, 26137 timeline: null, 26138 playbackRate: _playbackRate, 26139 pending: false, 26140 playState: immediate ? "idle" : "paused", 26141 replaceState: "active" 26142 }); 26143 const pending = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => store.pending); 26144 const playState = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => store.playState); 26145 const replaceState = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => store.replaceState); 26146 const startTime = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 26147 get() { 26148 return store.startTime; 26149 }, 26150 set(value) { 26151 store.startTime = value; 26152 if (animate.value) 26153 animate.value.startTime = value; 26154 } 26155 }); 26156 const currentTime = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 26157 get() { 26158 return store.currentTime; 26159 }, 26160 set(value) { 26161 store.currentTime = value; 26162 if (animate.value) { 26163 animate.value.currentTime = value; 26164 syncResume(); 26165 } 26166 } 26167 }); 26168 const timeline = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 26169 get() { 26170 return store.timeline; 26171 }, 26172 set(value) { 26173 store.timeline = value; 26174 if (animate.value) 26175 animate.value.timeline = value; 26176 } 26177 }); 26178 const playbackRate = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 26179 get() { 26180 return store.playbackRate; 26181 }, 26182 set(value) { 26183 store.playbackRate = value; 26184 if (animate.value) 26185 animate.value.playbackRate = value; 26186 } 26187 }); 26188 const play = () => { 26189 if (animate.value) { 26190 try { 26191 animate.value.play(); 26192 syncResume(); 26193 } catch (e) { 26194 syncPause(); 26195 onError(e); 26196 } 26197 } else { 26198 update(); 26199 } 26200 }; 26201 const pause = () => { 26202 var _a; 26203 try { 26204 (_a = animate.value) == null ? void 0 : _a.pause(); 26205 syncPause(); 26206 } catch (e) { 26207 onError(e); 26208 } 26209 }; 26210 const reverse = () => { 26211 var _a; 26212 if (!animate.value) 26213 update(); 26214 try { 26215 (_a = animate.value) == null ? void 0 : _a.reverse(); 26216 syncResume(); 26217 } catch (e) { 26218 syncPause(); 26219 onError(e); 26220 } 26221 }; 26222 const finish = () => { 26223 var _a; 26224 try { 26225 (_a = animate.value) == null ? void 0 : _a.finish(); 26226 syncPause(); 26227 } catch (e) { 26228 onError(e); 26229 } 26230 }; 26231 const cancel = () => { 26232 var _a; 26233 try { 26234 (_a = animate.value) == null ? void 0 : _a.cancel(); 26235 syncPause(); 26236 } catch (e) { 26237 onError(e); 26238 } 26239 }; 26240 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(() => unrefElement(target), (el) => { 26241 if (el) 26242 update(); 26243 }); 26244 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(() => keyframes, (value) => { 26245 if (animate.value) 26246 update(); 26247 if (!unrefElement(target) && animate.value) { 26248 animate.value.effect = new KeyframeEffect( 26249 unrefElement(target), 26250 (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(value), 26251 animateOptions 26252 ); 26253 } 26254 }, { deep: true }); 26255 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => update(true), false); 26256 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(cancel); 26257 function update(init) { 26258 const el = unrefElement(target); 26259 if (!isSupported.value || !el) 26260 return; 26261 if (!animate.value) 26262 animate.value = el.animate((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(keyframes), animateOptions); 26263 if (persist) 26264 animate.value.persist(); 26265 if (_playbackRate !== 1) 26266 animate.value.playbackRate = _playbackRate; 26267 if (init && !immediate) 26268 animate.value.pause(); 26269 else 26270 syncResume(); 26271 onReady == null ? undefined : onReady(animate.value); 26272 } 26273 const listenerOptions = { passive: true }; 26274 useEventListener(animate, ["cancel", "finish", "remove"], syncPause, listenerOptions); 26275 useEventListener(animate, "finish", () => { 26276 var _a; 26277 if (commitStyles) 26278 (_a = animate.value) == null ? undefined : _a.commitStyles(); 26279 }, listenerOptions); 26280 const { resume: resumeRef, pause: pauseRef } = useRafFn(() => { 26281 if (!animate.value) 26282 return; 26283 store.pending = animate.value.pending; 26284 store.playState = animate.value.playState; 26285 store.replaceState = animate.value.replaceState; 26286 store.startTime = animate.value.startTime; 26287 store.currentTime = animate.value.currentTime; 26288 store.timeline = animate.value.timeline; 26289 store.playbackRate = animate.value.playbackRate; 26290 }, { immediate: false }); 26291 function syncResume() { 26292 if (isSupported.value) 26293 resumeRef(); 26294 } 26295 function syncPause() { 26296 if (isSupported.value && window) 26297 window.requestAnimationFrame(pauseRef); 26298 } 26299 return { 26300 isSupported, 26301 animate, 26302 // actions 26303 play, 26304 pause, 26305 reverse, 26306 finish, 26307 cancel, 26308 // state 26309 pending, 26310 playState, 26311 replaceState, 26312 startTime, 26313 currentTime, 26314 timeline, 26315 playbackRate 26316 }; 26317} 26318 26319function useAsyncQueue(tasks, options) { 26320 const { 26321 interrupt = true, 26322 onError = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, 26323 onFinished = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, 26324 signal 26325 } = options || {}; 26326 const promiseState = { 26327 aborted: "aborted", 26328 fulfilled: "fulfilled", 26329 pending: "pending", 26330 rejected: "rejected" 26331 }; 26332 const initialResult = Array.from(Array.from({ length: tasks.length }), () => ({ state: promiseState.pending, data: null })); 26333 const result = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)(initialResult); 26334 const activeIndex = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(-1); 26335 if (!tasks || tasks.length === 0) { 26336 onFinished(); 26337 return { 26338 activeIndex, 26339 result 26340 }; 26341 } 26342 function updateResult(state, res) { 26343 activeIndex.value++; 26344 result[activeIndex.value].data = res; 26345 result[activeIndex.value].state = state; 26346 } 26347 tasks.reduce((prev, curr) => { 26348 return prev.then((prevRes) => { 26349 var _a; 26350 if (signal == null ? undefined : signal.aborted) { 26351 updateResult(promiseState.aborted, new Error("aborted")); 26352 return; 26353 } 26354 if (((_a = result[activeIndex.value]) == null ? undefined : _a.state) === promiseState.rejected && interrupt) { 26355 onFinished(); 26356 return; 26357 } 26358 const done = curr(prevRes).then((currentRes) => { 26359 updateResult(promiseState.fulfilled, currentRes); 26360 if (activeIndex.value === tasks.length - 1) 26361 onFinished(); 26362 return currentRes; 26363 }); 26364 if (!signal) 26365 return done; 26366 return Promise.race([done, whenAborted(signal)]); 26367 }).catch((e) => { 26368 if (signal == null ? undefined : signal.aborted) { 26369 updateResult(promiseState.aborted, e); 26370 return e; 26371 } 26372 updateResult(promiseState.rejected, e); 26373 onError(); 26374 return e; 26375 }); 26376 }, Promise.resolve()); 26377 return { 26378 activeIndex, 26379 result 26380 }; 26381} 26382function whenAborted(signal) { 26383 return new Promise((resolve, reject) => { 26384 const error = new Error("aborted"); 26385 if (signal.aborted) 26386 reject(error); 26387 else 26388 signal.addEventListener("abort", () => reject(error), { once: true }); 26389 }); 26390} 26391 26392function useAsyncState(promise, initialState, options) { 26393 const { 26394 immediate = true, 26395 delay = 0, 26396 onError = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, 26397 onSuccess = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, 26398 resetOnExecute = true, 26399 shallow = true, 26400 throwError 26401 } = options != null ? options : {}; 26402 const state = shallow ? (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(initialState) : (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialState); 26403 const isReady = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 26404 const isLoading = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 26405 const error = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(undefined); 26406 async function execute(delay2 = 0, ...args) { 26407 if (resetOnExecute) 26408 state.value = initialState; 26409 error.value = undefined; 26410 isReady.value = false; 26411 isLoading.value = true; 26412 if (delay2 > 0) 26413 await (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.promiseTimeout)(delay2); 26414 const _promise = typeof promise === "function" ? promise(...args) : promise; 26415 try { 26416 const data = await _promise; 26417 state.value = data; 26418 isReady.value = true; 26419 onSuccess(data); 26420 } catch (e) { 26421 error.value = e; 26422 onError(e); 26423 if (throwError) 26424 throw e; 26425 } finally { 26426 isLoading.value = false; 26427 } 26428 return state.value; 26429 } 26430 if (immediate) { 26431 execute(delay); 26432 } 26433 const shell = { 26434 state, 26435 isReady, 26436 isLoading, 26437 error, 26438 execute 26439 }; 26440 function waitUntilIsLoaded() { 26441 return new Promise((resolve, reject) => { 26442 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.until)(isLoading).toBe(false).then(() => resolve(shell)).catch(reject); 26443 }); 26444 } 26445 return { 26446 ...shell, 26447 then(onFulfilled, onRejected) { 26448 return waitUntilIsLoaded().then(onFulfilled, onRejected); 26449 } 26450 }; 26451} 26452 26453const defaults = { 26454 array: (v) => JSON.stringify(v), 26455 object: (v) => JSON.stringify(v), 26456 set: (v) => JSON.stringify(Array.from(v)), 26457 map: (v) => JSON.stringify(Object.fromEntries(v)), 26458 null: () => "" 26459}; 26460function getDefaultSerialization(target) { 26461 if (!target) 26462 return defaults.null; 26463 if (target instanceof Map) 26464 return defaults.map; 26465 else if (target instanceof Set) 26466 return defaults.set; 26467 else if (Array.isArray(target)) 26468 return defaults.array; 26469 else 26470 return defaults.object; 26471} 26472 26473function useBase64(target, options) { 26474 const base64 = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(""); 26475 const promise = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 26476 function execute() { 26477 if (!_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient) 26478 return; 26479 promise.value = new Promise((resolve, reject) => { 26480 try { 26481 const _target = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 26482 if (_target == null) { 26483 resolve(""); 26484 } else if (typeof _target === "string") { 26485 resolve(blobToBase64(new Blob([_target], { type: "text/plain" }))); 26486 } else if (_target instanceof Blob) { 26487 resolve(blobToBase64(_target)); 26488 } else if (_target instanceof ArrayBuffer) { 26489 resolve(window.btoa(String.fromCharCode(...new Uint8Array(_target)))); 26490 } else if (_target instanceof HTMLCanvasElement) { 26491 resolve(_target.toDataURL(options == null ? void 0 : options.type, options == null ? void 0 : options.quality)); 26492 } else if (_target instanceof HTMLImageElement) { 26493 const img = _target.cloneNode(false); 26494 img.crossOrigin = "Anonymous"; 26495 imgLoaded(img).then(() => { 26496 const canvas = document.createElement("canvas"); 26497 const ctx = canvas.getContext("2d"); 26498 canvas.width = img.width; 26499 canvas.height = img.height; 26500 ctx.drawImage(img, 0, 0, canvas.width, canvas.height); 26501 resolve(canvas.toDataURL(options == null ? void 0 : options.type, options == null ? void 0 : options.quality)); 26502 }).catch(reject); 26503 } else if (typeof _target === "object") { 26504 const _serializeFn = (options == null ? void 0 : options.serializer) || getDefaultSerialization(_target); 26505 const serialized = _serializeFn(_target); 26506 return resolve(blobToBase64(new Blob([serialized], { type: "application/json" }))); 26507 } else { 26508 reject(new Error("target is unsupported types")); 26509 } 26510 } catch (error) { 26511 reject(error); 26512 } 26513 }); 26514 promise.value.then((res) => { 26515 base64.value = (options == null ? undefined : options.dataUrl) === false ? res.replace(/^data:.*?;base64,/, "") : res; 26516 }); 26517 return promise.value; 26518 } 26519 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.isRef)(target) || typeof target === "function") 26520 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(target, execute, { immediate: true }); 26521 else 26522 execute(); 26523 return { 26524 base64, 26525 promise, 26526 execute 26527 }; 26528} 26529function imgLoaded(img) { 26530 return new Promise((resolve, reject) => { 26531 if (!img.complete) { 26532 img.onload = () => { 26533 resolve(); 26534 }; 26535 img.onerror = reject; 26536 } else { 26537 resolve(); 26538 } 26539 }); 26540} 26541function blobToBase64(blob) { 26542 return new Promise((resolve, reject) => { 26543 const fr = new FileReader(); 26544 fr.onload = (e) => { 26545 resolve(e.target.result); 26546 }; 26547 fr.onerror = reject; 26548 fr.readAsDataURL(blob); 26549 }); 26550} 26551 26552function useBattery(options = {}) { 26553 const { navigator = defaultNavigator } = options; 26554 const events = ["chargingchange", "chargingtimechange", "dischargingtimechange", "levelchange"]; 26555 const isSupported = useSupported(() => navigator && "getBattery" in navigator && typeof navigator.getBattery === "function"); 26556 const charging = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 26557 const chargingTime = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 26558 const dischargingTime = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 26559 const level = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(1); 26560 let battery; 26561 function updateBatteryInfo() { 26562 charging.value = this.charging; 26563 chargingTime.value = this.chargingTime || 0; 26564 dischargingTime.value = this.dischargingTime || 0; 26565 level.value = this.level; 26566 } 26567 if (isSupported.value) { 26568 navigator.getBattery().then((_battery) => { 26569 battery = _battery; 26570 updateBatteryInfo.call(battery); 26571 useEventListener(battery, events, updateBatteryInfo, { passive: true }); 26572 }); 26573 } 26574 return { 26575 isSupported, 26576 charging, 26577 chargingTime, 26578 dischargingTime, 26579 level 26580 }; 26581} 26582 26583function useBluetooth(options) { 26584 let { 26585 acceptAllDevices = false 26586 } = options || {}; 26587 const { 26588 filters = undefined, 26589 optionalServices = undefined, 26590 navigator = defaultNavigator 26591 } = options || {}; 26592 const isSupported = useSupported(() => navigator && "bluetooth" in navigator); 26593 const device = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(); 26594 const error = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(null); 26595 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(device, () => { 26596 connectToBluetoothGATTServer(); 26597 }); 26598 async function requestDevice() { 26599 if (!isSupported.value) 26600 return; 26601 error.value = null; 26602 if (filters && filters.length > 0) 26603 acceptAllDevices = false; 26604 try { 26605 device.value = await (navigator == null ? void 0 : navigator.bluetooth.requestDevice({ 26606 acceptAllDevices, 26607 filters, 26608 optionalServices 26609 })); 26610 } catch (err) { 26611 error.value = err; 26612 } 26613 } 26614 const server = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(); 26615 const isConnected = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(false); 26616 function reset() { 26617 isConnected.value = false; 26618 device.value = undefined; 26619 server.value = undefined; 26620 } 26621 async function connectToBluetoothGATTServer() { 26622 error.value = null; 26623 if (device.value && device.value.gatt) { 26624 useEventListener(device, "gattserverdisconnected", reset, { passive: true }); 26625 try { 26626 server.value = await device.value.gatt.connect(); 26627 isConnected.value = server.value.connected; 26628 } catch (err) { 26629 error.value = err; 26630 } 26631 } 26632 } 26633 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => { 26634 var _a; 26635 if (device.value) 26636 (_a = device.value.gatt) == null ? undefined : _a.connect(); 26637 }); 26638 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(() => { 26639 var _a; 26640 if (device.value) 26641 (_a = device.value.gatt) == null ? undefined : _a.disconnect(); 26642 }); 26643 return { 26644 isSupported, 26645 isConnected: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(isConnected), 26646 // Device: 26647 device, 26648 requestDevice, 26649 // Server: 26650 server, 26651 // Errors: 26652 error 26653 }; 26654} 26655 26656const ssrWidthSymbol = Symbol("vueuse-ssr-width"); 26657function useSSRWidth() { 26658 const ssrWidth = (0,vue__WEBPACK_IMPORTED_MODULE_1__.hasInjectionContext)() ? (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.injectLocal)(ssrWidthSymbol, null) : null; 26659 return typeof ssrWidth === "number" ? ssrWidth : undefined; 26660} 26661function provideSSRWidth(width, app) { 26662 if (app !== undefined) { 26663 app.provide(ssrWidthSymbol, width); 26664 } else { 26665 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.provideLocal)(ssrWidthSymbol, width); 26666 } 26667} 26668 26669function useMediaQuery(query, options = {}) { 26670 const { window = defaultWindow, ssrWidth = useSSRWidth() } = options; 26671 const isSupported = useSupported(() => window && "matchMedia" in window && typeof window.matchMedia === "function"); 26672 const ssrSupport = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(typeof ssrWidth === "number"); 26673 const mediaQuery = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(); 26674 const matches = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 26675 const handler = (event) => { 26676 matches.value = event.matches; 26677 }; 26678 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watchEffect)(() => { 26679 if (ssrSupport.value) { 26680 ssrSupport.value = !isSupported.value; 26681 const queryStrings = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(query).split(","); 26682 matches.value = queryStrings.some((queryString) => { 26683 const not = queryString.includes("not all"); 26684 const minWidth = queryString.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/); 26685 const maxWidth = queryString.match(/\(\s*max-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/); 26686 let res = Boolean(minWidth || maxWidth); 26687 if (minWidth && res) { 26688 res = ssrWidth >= (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pxValue)(minWidth[1]); 26689 } 26690 if (maxWidth && res) { 26691 res = ssrWidth <= (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pxValue)(maxWidth[1]); 26692 } 26693 return not ? !res : res; 26694 }); 26695 return; 26696 } 26697 if (!isSupported.value) 26698 return; 26699 mediaQuery.value = window.matchMedia((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(query)); 26700 matches.value = mediaQuery.value.matches; 26701 }); 26702 useEventListener(mediaQuery, "change", handler, { passive: true }); 26703 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => matches.value); 26704} 26705 26706const breakpointsTailwind = { 26707 "sm": 640, 26708 "md": 768, 26709 "lg": 1024, 26710 "xl": 1280, 26711 "2xl": 1536 26712}; 26713const breakpointsBootstrapV5 = { 26714 xs: 0, 26715 sm: 576, 26716 md: 768, 26717 lg: 992, 26718 xl: 1200, 26719 xxl: 1400 26720}; 26721const breakpointsVuetifyV2 = { 26722 xs: 0, 26723 sm: 600, 26724 md: 960, 26725 lg: 1264, 26726 xl: 1904 26727}; 26728const breakpointsVuetifyV3 = { 26729 xs: 0, 26730 sm: 600, 26731 md: 960, 26732 lg: 1280, 26733 xl: 1920, 26734 xxl: 2560 26735}; 26736const breakpointsVuetify = breakpointsVuetifyV2; 26737const breakpointsAntDesign = { 26738 xs: 480, 26739 sm: 576, 26740 md: 768, 26741 lg: 992, 26742 xl: 1200, 26743 xxl: 1600 26744}; 26745const breakpointsQuasar = { 26746 xs: 0, 26747 sm: 600, 26748 md: 1024, 26749 lg: 1440, 26750 xl: 1920 26751}; 26752const breakpointsSematic = { 26753 mobileS: 320, 26754 mobileM: 375, 26755 mobileL: 425, 26756 tablet: 768, 26757 laptop: 1024, 26758 laptopL: 1440, 26759 desktop4K: 2560 26760}; 26761const breakpointsMasterCss = { 26762 "3xs": 360, 26763 "2xs": 480, 26764 "xs": 600, 26765 "sm": 768, 26766 "md": 1024, 26767 "lg": 1280, 26768 "xl": 1440, 26769 "2xl": 1600, 26770 "3xl": 1920, 26771 "4xl": 2560 26772}; 26773const breakpointsPrimeFlex = { 26774 sm: 576, 26775 md: 768, 26776 lg: 992, 26777 xl: 1200 26778}; 26779const breakpointsElement = { 26780 xs: 0, 26781 sm: 768, 26782 md: 992, 26783 lg: 1200, 26784 xl: 1920 26785}; 26786 26787function useBreakpoints(breakpoints, options = {}) { 26788 function getValue(k, delta) { 26789 let v = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(breakpoints[(0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(k)]); 26790 if (delta != null) 26791 v = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.increaseWithUnit)(v, delta); 26792 if (typeof v === "number") 26793 v = `${v}px`; 26794 return v; 26795 } 26796 const { window = defaultWindow, strategy = "min-width", ssrWidth = useSSRWidth() } = options; 26797 const ssrSupport = typeof ssrWidth === "number"; 26798 const mounted = ssrSupport ? (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false) : { value: true }; 26799 if (ssrSupport) { 26800 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => mounted.value = !!window); 26801 } 26802 function match(query, size) { 26803 if (!mounted.value && ssrSupport) { 26804 return query === "min" ? ssrWidth >= (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pxValue)(size) : ssrWidth <= (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pxValue)(size); 26805 } 26806 if (!window) 26807 return false; 26808 return window.matchMedia(`(${query}-width: ${size})`).matches; 26809 } 26810 const greaterOrEqual = (k) => { 26811 return useMediaQuery(() => `(min-width: ${getValue(k)})`, options); 26812 }; 26813 const smallerOrEqual = (k) => { 26814 return useMediaQuery(() => `(max-width: ${getValue(k)})`, options); 26815 }; 26816 const shortcutMethods = Object.keys(breakpoints).reduce((shortcuts, k) => { 26817 Object.defineProperty(shortcuts, k, { 26818 get: () => strategy === "min-width" ? greaterOrEqual(k) : smallerOrEqual(k), 26819 enumerable: true, 26820 configurable: true 26821 }); 26822 return shortcuts; 26823 }, {}); 26824 function current() { 26825 const points = Object.keys(breakpoints).map((k) => [k, shortcutMethods[k], (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pxValue)(getValue(k))]).sort((a, b) => a[2] - b[2]); 26826 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => points.filter(([, v]) => v.value).map(([k]) => k)); 26827 } 26828 return Object.assign(shortcutMethods, { 26829 greaterOrEqual, 26830 smallerOrEqual, 26831 greater(k) { 26832 return useMediaQuery(() => `(min-width: ${getValue(k, 0.1)})`, options); 26833 }, 26834 smaller(k) { 26835 return useMediaQuery(() => `(max-width: ${getValue(k, -0.1)})`, options); 26836 }, 26837 between(a, b) { 26838 return useMediaQuery(() => `(min-width: ${getValue(a)}) and (max-width: ${getValue(b, -0.1)})`, options); 26839 }, 26840 isGreater(k) { 26841 return match("min", getValue(k, 0.1)); 26842 }, 26843 isGreaterOrEqual(k) { 26844 return match("min", getValue(k)); 26845 }, 26846 isSmaller(k) { 26847 return match("max", getValue(k, -0.1)); 26848 }, 26849 isSmallerOrEqual(k) { 26850 return match("max", getValue(k)); 26851 }, 26852 isInBetween(a, b) { 26853 return match("min", getValue(a)) && match("max", getValue(b, -0.1)); 26854 }, 26855 current, 26856 active() { 26857 const bps = current(); 26858 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => bps.value.length === 0 ? "" : bps.value.at(strategy === "min-width" ? -1 : 0)); 26859 } 26860 }); 26861} 26862 26863function useBroadcastChannel(options) { 26864 const { 26865 name, 26866 window = defaultWindow 26867 } = options; 26868 const isSupported = useSupported(() => window && "BroadcastChannel" in window); 26869 const isClosed = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 26870 const channel = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 26871 const data = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 26872 const error = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(null); 26873 const post = (data2) => { 26874 if (channel.value) 26875 channel.value.postMessage(data2); 26876 }; 26877 const close = () => { 26878 if (channel.value) 26879 channel.value.close(); 26880 isClosed.value = true; 26881 }; 26882 if (isSupported.value) { 26883 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => { 26884 error.value = null; 26885 channel.value = new BroadcastChannel(name); 26886 const listenerOptions = { 26887 passive: true 26888 }; 26889 useEventListener(channel, "message", (e) => { 26890 data.value = e.data; 26891 }, listenerOptions); 26892 useEventListener(channel, "messageerror", (e) => { 26893 error.value = e; 26894 }, listenerOptions); 26895 useEventListener(channel, "close", () => { 26896 isClosed.value = true; 26897 }, listenerOptions); 26898 }); 26899 } 26900 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(() => { 26901 close(); 26902 }); 26903 return { 26904 isSupported, 26905 channel, 26906 data, 26907 post, 26908 close, 26909 error, 26910 isClosed 26911 }; 26912} 26913 26914const WRITABLE_PROPERTIES = [ 26915 "hash", 26916 "host", 26917 "hostname", 26918 "href", 26919 "pathname", 26920 "port", 26921 "protocol", 26922 "search" 26923]; 26924function useBrowserLocation(options = {}) { 26925 const { window = defaultWindow } = options; 26926 const refs = Object.fromEntries( 26927 WRITABLE_PROPERTIES.map((key) => [key, (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)()]) 26928 ); 26929 for (const [key, ref2] of (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.objectEntries)(refs)) { 26930 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(ref2, (value) => { 26931 if (!(window == null ? undefined : window.location) || window.location[key] === value) 26932 return; 26933 window.location[key] = value; 26934 }); 26935 } 26936 const buildState = (trigger) => { 26937 var _a; 26938 const { state: state2, length } = (window == null ? undefined : window.history) || {}; 26939 const { origin } = (window == null ? undefined : window.location) || {}; 26940 for (const key of WRITABLE_PROPERTIES) 26941 refs[key].value = (_a = window == null ? undefined : window.location) == null ? undefined : _a[key]; 26942 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)({ 26943 trigger, 26944 state: state2, 26945 length, 26946 origin, 26947 ...refs 26948 }); 26949 }; 26950 const state = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(buildState("load")); 26951 if (window) { 26952 const listenerOptions = { passive: true }; 26953 useEventListener(window, "popstate", () => state.value = buildState("popstate"), listenerOptions); 26954 useEventListener(window, "hashchange", () => state.value = buildState("hashchange"), listenerOptions); 26955 } 26956 return state; 26957} 26958 26959function useCached(refValue, comparator = (a, b) => a === b, watchOptions) { 26960 const cachedValue = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(refValue.value); 26961 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(() => refValue.value, (value) => { 26962 if (!comparator(value, cachedValue.value)) 26963 cachedValue.value = value; 26964 }, watchOptions); 26965 return cachedValue; 26966} 26967 26968function usePermission(permissionDesc, options = {}) { 26969 const { 26970 controls = false, 26971 navigator = defaultNavigator 26972 } = options; 26973 const isSupported = useSupported(() => navigator && "permissions" in navigator); 26974 const permissionStatus = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(); 26975 const desc = typeof permissionDesc === "string" ? { name: permissionDesc } : permissionDesc; 26976 const state = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(); 26977 const update = () => { 26978 var _a, _b; 26979 state.value = (_b = (_a = permissionStatus.value) == null ? undefined : _a.state) != null ? _b : "prompt"; 26980 }; 26981 useEventListener(permissionStatus, "change", update, { passive: true }); 26982 const query = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createSingletonPromise)(async () => { 26983 if (!isSupported.value) 26984 return; 26985 if (!permissionStatus.value) { 26986 try { 26987 permissionStatus.value = await navigator.permissions.query(desc); 26988 } catch (e) { 26989 permissionStatus.value = undefined; 26990 } finally { 26991 update(); 26992 } 26993 } 26994 if (controls) 26995 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.toRaw)(permissionStatus.value); 26996 }); 26997 query(); 26998 if (controls) { 26999 return { 27000 state, 27001 isSupported, 27002 query 27003 }; 27004 } else { 27005 return state; 27006 } 27007} 27008 27009function useClipboard(options = {}) { 27010 const { 27011 navigator = defaultNavigator, 27012 read = false, 27013 source, 27014 copiedDuring = 1500, 27015 legacy = false 27016 } = options; 27017 const isClipboardApiSupported = useSupported(() => navigator && "clipboard" in navigator); 27018 const permissionRead = usePermission("clipboard-read"); 27019 const permissionWrite = usePermission("clipboard-write"); 27020 const isSupported = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => isClipboardApiSupported.value || legacy); 27021 const text = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(""); 27022 const copied = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 27023 const timeout = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useTimeoutFn)(() => copied.value = false, copiedDuring, { immediate: false }); 27024 function updateText() { 27025 let useLegacy = !(isClipboardApiSupported.value && isAllowed(permissionRead.value)); 27026 if (!useLegacy) { 27027 try { 27028 navigator.clipboard.readText().then((value) => { 27029 text.value = value; 27030 }); 27031 } catch (e) { 27032 useLegacy = true; 27033 } 27034 } 27035 if (useLegacy) { 27036 text.value = legacyRead(); 27037 } 27038 } 27039 if (isSupported.value && read) 27040 useEventListener(["copy", "cut"], updateText, { passive: true }); 27041 async function copy(value = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(source)) { 27042 if (isSupported.value && value != null) { 27043 let useLegacy = !(isClipboardApiSupported.value && isAllowed(permissionWrite.value)); 27044 if (!useLegacy) { 27045 try { 27046 await navigator.clipboard.writeText(value); 27047 } catch (e) { 27048 useLegacy = true; 27049 } 27050 } 27051 if (useLegacy) 27052 legacyCopy(value); 27053 text.value = value; 27054 copied.value = true; 27055 timeout.start(); 27056 } 27057 } 27058 function legacyCopy(value) { 27059 const ta = document.createElement("textarea"); 27060 ta.value = value != null ? value : ""; 27061 ta.style.position = "absolute"; 27062 ta.style.opacity = "0"; 27063 document.body.appendChild(ta); 27064 ta.select(); 27065 document.execCommand("copy"); 27066 ta.remove(); 27067 } 27068 function legacyRead() { 27069 var _a, _b, _c; 27070 return (_c = (_b = (_a = document == null ? undefined : document.getSelection) == null ? undefined : _a.call(document)) == null ? undefined : _b.toString()) != null ? _c : ""; 27071 } 27072 function isAllowed(status) { 27073 return status === "granted" || status === "prompt"; 27074 } 27075 return { 27076 isSupported, 27077 text, 27078 copied, 27079 copy 27080 }; 27081} 27082 27083function useClipboardItems(options = {}) { 27084 const { 27085 navigator = defaultNavigator, 27086 read = false, 27087 source, 27088 copiedDuring = 1500 27089 } = options; 27090 const isSupported = useSupported(() => navigator && "clipboard" in navigator); 27091 const content = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)([]); 27092 const copied = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 27093 const timeout = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useTimeoutFn)(() => copied.value = false, copiedDuring, { immediate: false }); 27094 function updateContent() { 27095 if (isSupported.value) { 27096 navigator.clipboard.read().then((items) => { 27097 content.value = items; 27098 }); 27099 } 27100 } 27101 if (isSupported.value && read) 27102 useEventListener(["copy", "cut"], updateContent, { passive: true }); 27103 async function copy(value = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(source)) { 27104 if (isSupported.value && value != null) { 27105 await navigator.clipboard.write(value); 27106 content.value = value; 27107 copied.value = true; 27108 timeout.start(); 27109 } 27110 } 27111 return { 27112 isSupported, 27113 content, 27114 copied, 27115 copy 27116 }; 27117} 27118 27119function cloneFnJSON(source) { 27120 return JSON.parse(JSON.stringify(source)); 27121} 27122function useCloned(source, options = {}) { 27123 const cloned = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)({}); 27124 const isModified = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 27125 let _lastSync = false; 27126 const { 27127 manual, 27128 clone = cloneFnJSON, 27129 // watch options 27130 deep = true, 27131 immediate = true 27132 } = options; 27133 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(cloned, () => { 27134 if (_lastSync) { 27135 _lastSync = false; 27136 return; 27137 } 27138 isModified.value = true; 27139 }, { 27140 deep: true, 27141 flush: "sync" 27142 }); 27143 function sync() { 27144 _lastSync = true; 27145 isModified.value = false; 27146 cloned.value = clone((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(source)); 27147 } 27148 if (!manual && ((0,vue__WEBPACK_IMPORTED_MODULE_1__.isRef)(source) || typeof source === "function")) { 27149 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(source, sync, { 27150 ...options, 27151 deep, 27152 immediate 27153 }); 27154 } else { 27155 sync(); 27156 } 27157 return { cloned, isModified, sync }; 27158} 27159 27160const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {}; 27161const globalKey = "__vueuse_ssr_handlers__"; 27162const handlers = /* @__PURE__ */ getHandlers(); 27163function getHandlers() { 27164 if (!(globalKey in _global)) 27165 _global[globalKey] = _global[globalKey] || {}; 27166 return _global[globalKey]; 27167} 27168function getSSRHandler(key, fallback) { 27169 return handlers[key] || fallback; 27170} 27171function setSSRHandler(key, fn) { 27172 handlers[key] = fn; 27173} 27174 27175function usePreferredDark(options) { 27176 return useMediaQuery("(prefers-color-scheme: dark)", options); 27177} 27178 27179function guessSerializerType(rawInit) { 27180 return rawInit == null ? "any" : rawInit instanceof Set ? "set" : rawInit instanceof Map ? "map" : rawInit instanceof Date ? "date" : typeof rawInit === "boolean" ? "boolean" : typeof rawInit === "string" ? "string" : typeof rawInit === "object" ? "object" : !Number.isNaN(rawInit) ? "number" : "any"; 27181} 27182 27183const StorageSerializers = { 27184 boolean: { 27185 read: (v) => v === "true", 27186 write: (v) => String(v) 27187 }, 27188 object: { 27189 read: (v) => JSON.parse(v), 27190 write: (v) => JSON.stringify(v) 27191 }, 27192 number: { 27193 read: (v) => Number.parseFloat(v), 27194 write: (v) => String(v) 27195 }, 27196 any: { 27197 read: (v) => v, 27198 write: (v) => String(v) 27199 }, 27200 string: { 27201 read: (v) => v, 27202 write: (v) => String(v) 27203 }, 27204 map: { 27205 read: (v) => new Map(JSON.parse(v)), 27206 write: (v) => JSON.stringify(Array.from(v.entries())) 27207 }, 27208 set: { 27209 read: (v) => new Set(JSON.parse(v)), 27210 write: (v) => JSON.stringify(Array.from(v)) 27211 }, 27212 date: { 27213 read: (v) => new Date(v), 27214 write: (v) => v.toISOString() 27215 } 27216}; 27217const customStorageEventName = "vueuse-storage"; 27218function useStorage(key, defaults, storage, options = {}) { 27219 var _a; 27220 const { 27221 flush = "pre", 27222 deep = true, 27223 listenToStorageChanges = true, 27224 writeDefaults = true, 27225 mergeDefaults = false, 27226 shallow, 27227 window = defaultWindow, 27228 eventFilter, 27229 onError = (e) => { 27230 console.error(e); 27231 }, 27232 initOnMounted 27233 } = options; 27234 const data = (shallow ? vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef : vue__WEBPACK_IMPORTED_MODULE_1__.ref)(typeof defaults === "function" ? defaults() : defaults); 27235 const keyComputed = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(key)); 27236 if (!storage) { 27237 try { 27238 storage = getSSRHandler("getDefaultStorage", () => { 27239 var _a2; 27240 return (_a2 = defaultWindow) == null ? void 0 : _a2.localStorage; 27241 })(); 27242 } catch (e) { 27243 onError(e); 27244 } 27245 } 27246 if (!storage) 27247 return data; 27248 const rawInit = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(defaults); 27249 const type = guessSerializerType(rawInit); 27250 const serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type]; 27251 const { pause: pauseWatch, resume: resumeWatch } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pausableWatch)( 27252 data, 27253 () => write(data.value), 27254 { flush, deep, eventFilter } 27255 ); 27256 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(keyComputed, () => update(), { flush }); 27257 if (window && listenToStorageChanges) { 27258 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => { 27259 if (storage instanceof Storage) 27260 useEventListener(window, "storage", update, { passive: true }); 27261 else 27262 useEventListener(window, customStorageEventName, updateFromCustomEvent); 27263 if (initOnMounted) 27264 update(); 27265 }); 27266 } 27267 if (!initOnMounted) 27268 update(); 27269 function dispatchWriteEvent(oldValue, newValue) { 27270 if (window) { 27271 const payload = { 27272 key: keyComputed.value, 27273 oldValue, 27274 newValue, 27275 storageArea: storage 27276 }; 27277 window.dispatchEvent(storage instanceof Storage ? new StorageEvent("storage", payload) : new CustomEvent(customStorageEventName, { 27278 detail: payload 27279 })); 27280 } 27281 } 27282 function write(v) { 27283 try { 27284 const oldValue = storage.getItem(keyComputed.value); 27285 if (v == null) { 27286 dispatchWriteEvent(oldValue, null); 27287 storage.removeItem(keyComputed.value); 27288 } else { 27289 const serialized = serializer.write(v); 27290 if (oldValue !== serialized) { 27291 storage.setItem(keyComputed.value, serialized); 27292 dispatchWriteEvent(oldValue, serialized); 27293 } 27294 } 27295 } catch (e) { 27296 onError(e); 27297 } 27298 } 27299 function read(event) { 27300 const rawValue = event ? event.newValue : storage.getItem(keyComputed.value); 27301 if (rawValue == null) { 27302 if (writeDefaults && rawInit != null) 27303 storage.setItem(keyComputed.value, serializer.write(rawInit)); 27304 return rawInit; 27305 } else if (!event && mergeDefaults) { 27306 const value = serializer.read(rawValue); 27307 if (typeof mergeDefaults === "function") 27308 return mergeDefaults(value, rawInit); 27309 else if (type === "object" && !Array.isArray(value)) 27310 return { ...rawInit, ...value }; 27311 return value; 27312 } else if (typeof rawValue !== "string") { 27313 return rawValue; 27314 } else { 27315 return serializer.read(rawValue); 27316 } 27317 } 27318 function update(event) { 27319 if (event && event.storageArea !== storage) 27320 return; 27321 if (event && event.key == null) { 27322 data.value = rawInit; 27323 return; 27324 } 27325 if (event && event.key !== keyComputed.value) 27326 return; 27327 pauseWatch(); 27328 try { 27329 if ((event == null ? void 0 : event.newValue) !== serializer.write(data.value)) 27330 data.value = read(event); 27331 } catch (e) { 27332 onError(e); 27333 } finally { 27334 if (event) 27335 (0,vue__WEBPACK_IMPORTED_MODULE_1__.nextTick)(resumeWatch); 27336 else 27337 resumeWatch(); 27338 } 27339 } 27340 function updateFromCustomEvent(event) { 27341 update(event.detail); 27342 } 27343 return data; 27344} 27345 27346const CSS_DISABLE_TRANS = "*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}"; 27347function useColorMode(options = {}) { 27348 const { 27349 selector = "html", 27350 attribute = "class", 27351 initialValue = "auto", 27352 window = defaultWindow, 27353 storage, 27354 storageKey = "vueuse-color-scheme", 27355 listenToStorageChanges = true, 27356 storageRef, 27357 emitAuto, 27358 disableTransition = true 27359 } = options; 27360 const modes = { 27361 auto: "", 27362 light: "light", 27363 dark: "dark", 27364 ...options.modes || {} 27365 }; 27366 const preferredDark = usePreferredDark({ window }); 27367 const system = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => preferredDark.value ? "dark" : "light"); 27368 const store = storageRef || (storageKey == null ? (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(initialValue) : useStorage(storageKey, initialValue, storage, { window, listenToStorageChanges })); 27369 const state = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => store.value === "auto" ? system.value : store.value); 27370 const updateHTMLAttrs = getSSRHandler( 27371 "updateHTMLAttrs", 27372 (selector2, attribute2, value) => { 27373 const el = typeof selector2 === "string" ? window == null ? undefined : window.document.querySelector(selector2) : unrefElement(selector2); 27374 if (!el) 27375 return; 27376 const classesToAdd = /* @__PURE__ */ new Set(); 27377 const classesToRemove = /* @__PURE__ */ new Set(); 27378 let attributeToChange = null; 27379 if (attribute2 === "class") { 27380 const current = value.split(/\s/g); 27381 Object.values(modes).flatMap((i) => (i || "").split(/\s/g)).filter(Boolean).forEach((v) => { 27382 if (current.includes(v)) 27383 classesToAdd.add(v); 27384 else 27385 classesToRemove.add(v); 27386 }); 27387 } else { 27388 attributeToChange = { key: attribute2, value }; 27389 } 27390 if (classesToAdd.size === 0 && classesToRemove.size === 0 && attributeToChange === null) 27391 return; 27392 let style; 27393 if (disableTransition) { 27394 style = window.document.createElement("style"); 27395 style.appendChild(document.createTextNode(CSS_DISABLE_TRANS)); 27396 window.document.head.appendChild(style); 27397 } 27398 for (const c of classesToAdd) { 27399 el.classList.add(c); 27400 } 27401 for (const c of classesToRemove) { 27402 el.classList.remove(c); 27403 } 27404 if (attributeToChange) { 27405 el.setAttribute(attributeToChange.key, attributeToChange.value); 27406 } 27407 if (disableTransition) { 27408 window.getComputedStyle(style).opacity; 27409 document.head.removeChild(style); 27410 } 27411 } 27412 ); 27413 function defaultOnChanged(mode) { 27414 var _a; 27415 updateHTMLAttrs(selector, attribute, (_a = modes[mode]) != null ? _a : mode); 27416 } 27417 function onChanged(mode) { 27418 if (options.onChanged) 27419 options.onChanged(mode, defaultOnChanged); 27420 else 27421 defaultOnChanged(mode); 27422 } 27423 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(state, onChanged, { flush: "post", immediate: true }); 27424 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => onChanged(state.value)); 27425 const auto = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 27426 get() { 27427 return emitAuto ? store.value : state.value; 27428 }, 27429 set(v) { 27430 store.value = v; 27431 } 27432 }); 27433 return Object.assign(auto, { store, system, state }); 27434} 27435 27436function useConfirmDialog(revealed = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false)) { 27437 const confirmHook = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 27438 const cancelHook = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 27439 const revealHook = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 27440 let _resolve = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop; 27441 const reveal = (data) => { 27442 revealHook.trigger(data); 27443 revealed.value = true; 27444 return new Promise((resolve) => { 27445 _resolve = resolve; 27446 }); 27447 }; 27448 const confirm = (data) => { 27449 revealed.value = false; 27450 confirmHook.trigger(data); 27451 _resolve({ data, isCanceled: false }); 27452 }; 27453 const cancel = (data) => { 27454 revealed.value = false; 27455 cancelHook.trigger(data); 27456 _resolve({ data, isCanceled: true }); 27457 }; 27458 return { 27459 isRevealed: (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => revealed.value), 27460 reveal, 27461 confirm, 27462 cancel, 27463 onReveal: revealHook.on, 27464 onConfirm: confirmHook.on, 27465 onCancel: cancelHook.on 27466 }; 27467} 27468 27469function useCountdown(initialCountdown, options) { 27470 var _a, _b; 27471 const remaining = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(initialCountdown)); 27472 const intervalController = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useIntervalFn)(() => { 27473 var _a2, _b2; 27474 const value = remaining.value - 1; 27475 remaining.value = value < 0 ? 0 : value; 27476 (_a2 = options == null ? undefined : options.onTick) == null ? undefined : _a2.call(options); 27477 if (remaining.value <= 0) { 27478 intervalController.pause(); 27479 (_b2 = options == null ? undefined : options.onComplete) == null ? undefined : _b2.call(options); 27480 } 27481 }, (_a = options == null ? undefined : options.interval) != null ? _a : 1e3, { immediate: (_b = options == null ? undefined : options.immediate) != null ? _b : false }); 27482 const reset = () => { 27483 remaining.value = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(initialCountdown); 27484 }; 27485 const stop = () => { 27486 intervalController.pause(); 27487 reset(); 27488 }; 27489 const resume = () => { 27490 if (!intervalController.isActive.value) { 27491 if (remaining.value > 0) { 27492 intervalController.resume(); 27493 } 27494 } 27495 }; 27496 const start = () => { 27497 reset(); 27498 intervalController.resume(); 27499 }; 27500 return { 27501 remaining, 27502 reset, 27503 stop, 27504 start, 27505 pause: intervalController.pause, 27506 resume, 27507 isActive: intervalController.isActive 27508 }; 27509} 27510 27511function useCssVar(prop, target, options = {}) { 27512 const { window = defaultWindow, initialValue, observe = false } = options; 27513 const variable = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialValue); 27514 const elRef = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 27515 var _a; 27516 return unrefElement(target) || ((_a = window == null ? undefined : window.document) == null ? undefined : _a.documentElement); 27517 }); 27518 function updateCssVar() { 27519 var _a; 27520 const key = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(prop); 27521 const el = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(elRef); 27522 if (el && window && key) { 27523 const value = (_a = window.getComputedStyle(el).getPropertyValue(key)) == null ? undefined : _a.trim(); 27524 variable.value = value || initialValue; 27525 } 27526 } 27527 if (observe) { 27528 useMutationObserver(elRef, updateCssVar, { 27529 attributeFilter: ["style", "class"], 27530 window 27531 }); 27532 } 27533 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 27534 [elRef, () => (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(prop)], 27535 (_, old) => { 27536 if (old[0] && old[1]) 27537 old[0].style.removeProperty(old[1]); 27538 updateCssVar(); 27539 }, 27540 { immediate: true } 27541 ); 27542 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 27543 variable, 27544 (val) => { 27545 var _a; 27546 const raw_prop = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(prop); 27547 if (((_a = elRef.value) == null ? undefined : _a.style) && raw_prop) { 27548 if (val == null) 27549 elRef.value.style.removeProperty(raw_prop); 27550 else 27551 elRef.value.style.setProperty(raw_prop, val); 27552 } 27553 } 27554 ); 27555 return variable; 27556} 27557 27558function useCurrentElement(rootComponent) { 27559 const vm = (0,vue__WEBPACK_IMPORTED_MODULE_1__.getCurrentInstance)(); 27560 const currentElement = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.computedWithControl)( 27561 () => null, 27562 () => rootComponent ? unrefElement(rootComponent) : vm.proxy.$el 27563 ); 27564 (0,vue__WEBPACK_IMPORTED_MODULE_1__.onUpdated)(currentElement.trigger); 27565 (0,vue__WEBPACK_IMPORTED_MODULE_1__.onMounted)(currentElement.trigger); 27566 return currentElement; 27567} 27568 27569function useCycleList(list, options) { 27570 const state = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(getInitialValue()); 27571 const listRef = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(list); 27572 const index = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 27573 get() { 27574 var _a; 27575 const targetList = listRef.value; 27576 let index2 = (options == null ? undefined : options.getIndexOf) ? options.getIndexOf(state.value, targetList) : targetList.indexOf(state.value); 27577 if (index2 < 0) 27578 index2 = (_a = options == null ? undefined : options.fallbackIndex) != null ? _a : 0; 27579 return index2; 27580 }, 27581 set(v) { 27582 set(v); 27583 } 27584 }); 27585 function set(i) { 27586 const targetList = listRef.value; 27587 const length = targetList.length; 27588 const index2 = (i % length + length) % length; 27589 const value = targetList[index2]; 27590 state.value = value; 27591 return value; 27592 } 27593 function shift(delta = 1) { 27594 return set(index.value + delta); 27595 } 27596 function next(n = 1) { 27597 return shift(n); 27598 } 27599 function prev(n = 1) { 27600 return shift(-n); 27601 } 27602 function getInitialValue() { 27603 var _a, _b; 27604 return (_b = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)((_a = options == null ? undefined : options.initialValue) != null ? _a : (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(list)[0])) != null ? _b : undefined; 27605 } 27606 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(listRef, () => set(index.value)); 27607 return { 27608 state, 27609 index, 27610 next, 27611 prev, 27612 go: set 27613 }; 27614} 27615 27616function useDark(options = {}) { 27617 const { 27618 valueDark = "dark", 27619 valueLight = "" 27620 } = options; 27621 const mode = useColorMode({ 27622 ...options, 27623 onChanged: (mode2, defaultHandler) => { 27624 var _a; 27625 if (options.onChanged) 27626 (_a = options.onChanged) == null ? undefined : _a.call(options, mode2 === "dark", defaultHandler, mode2); 27627 else 27628 defaultHandler(mode2); 27629 }, 27630 modes: { 27631 dark: valueDark, 27632 light: valueLight 27633 } 27634 }); 27635 const system = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => mode.system.value); 27636 const isDark = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 27637 get() { 27638 return mode.value === "dark"; 27639 }, 27640 set(v) { 27641 const modeVal = v ? "dark" : "light"; 27642 if (system.value === modeVal) 27643 mode.value = "auto"; 27644 else 27645 mode.value = modeVal; 27646 } 27647 }); 27648 return isDark; 27649} 27650 27651function fnBypass(v) { 27652 return v; 27653} 27654function fnSetSource(source, value) { 27655 return source.value = value; 27656} 27657function defaultDump(clone) { 27658 return clone ? typeof clone === "function" ? clone : cloneFnJSON : fnBypass; 27659} 27660function defaultParse(clone) { 27661 return clone ? typeof clone === "function" ? clone : cloneFnJSON : fnBypass; 27662} 27663function useManualRefHistory(source, options = {}) { 27664 const { 27665 clone = false, 27666 dump = defaultDump(clone), 27667 parse = defaultParse(clone), 27668 setSource = fnSetSource 27669 } = options; 27670 function _createHistoryRecord() { 27671 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.markRaw)({ 27672 snapshot: dump(source.value), 27673 timestamp: (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.timestamp)() 27674 }); 27675 } 27676 const last = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(_createHistoryRecord()); 27677 const undoStack = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)([]); 27678 const redoStack = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)([]); 27679 const _setSource = (record) => { 27680 setSource(source, parse(record.snapshot)); 27681 last.value = record; 27682 }; 27683 const commit = () => { 27684 undoStack.value.unshift(last.value); 27685 last.value = _createHistoryRecord(); 27686 if (options.capacity && undoStack.value.length > options.capacity) 27687 undoStack.value.splice(options.capacity, Number.POSITIVE_INFINITY); 27688 if (redoStack.value.length) 27689 redoStack.value.splice(0, redoStack.value.length); 27690 }; 27691 const clear = () => { 27692 undoStack.value.splice(0, undoStack.value.length); 27693 redoStack.value.splice(0, redoStack.value.length); 27694 }; 27695 const undo = () => { 27696 const state = undoStack.value.shift(); 27697 if (state) { 27698 redoStack.value.unshift(last.value); 27699 _setSource(state); 27700 } 27701 }; 27702 const redo = () => { 27703 const state = redoStack.value.shift(); 27704 if (state) { 27705 undoStack.value.unshift(last.value); 27706 _setSource(state); 27707 } 27708 }; 27709 const reset = () => { 27710 _setSource(last.value); 27711 }; 27712 const history = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => [last.value, ...undoStack.value]); 27713 const canUndo = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => undoStack.value.length > 0); 27714 const canRedo = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => redoStack.value.length > 0); 27715 return { 27716 source, 27717 undoStack, 27718 redoStack, 27719 last, 27720 history, 27721 canUndo, 27722 canRedo, 27723 clear, 27724 commit, 27725 reset, 27726 undo, 27727 redo 27728 }; 27729} 27730 27731function useRefHistory(source, options = {}) { 27732 const { 27733 deep = false, 27734 flush = "pre", 27735 eventFilter 27736 } = options; 27737 const { 27738 eventFilter: composedFilter, 27739 pause, 27740 resume: resumeTracking, 27741 isActive: isTracking 27742 } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pausableFilter)(eventFilter); 27743 const { 27744 ignoreUpdates, 27745 ignorePrevAsyncUpdates, 27746 stop 27747 } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchIgnorable)( 27748 source, 27749 commit, 27750 { deep, flush, eventFilter: composedFilter } 27751 ); 27752 function setSource(source2, value) { 27753 ignorePrevAsyncUpdates(); 27754 ignoreUpdates(() => { 27755 source2.value = value; 27756 }); 27757 } 27758 const manualHistory = useManualRefHistory(source, { ...options, clone: options.clone || deep, setSource }); 27759 const { clear, commit: manualCommit } = manualHistory; 27760 function commit() { 27761 ignorePrevAsyncUpdates(); 27762 manualCommit(); 27763 } 27764 function resume(commitNow) { 27765 resumeTracking(); 27766 if (commitNow) 27767 commit(); 27768 } 27769 function batch(fn) { 27770 let canceled = false; 27771 const cancel = () => canceled = true; 27772 ignoreUpdates(() => { 27773 fn(cancel); 27774 }); 27775 if (!canceled) 27776 commit(); 27777 } 27778 function dispose() { 27779 stop(); 27780 clear(); 27781 } 27782 return { 27783 ...manualHistory, 27784 isTracking, 27785 pause, 27786 resume, 27787 commit, 27788 batch, 27789 dispose 27790 }; 27791} 27792 27793function useDebouncedRefHistory(source, options = {}) { 27794 const filter = options.debounce ? (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.debounceFilter)(options.debounce) : undefined; 27795 const history = useRefHistory(source, { ...options, eventFilter: filter }); 27796 return { 27797 ...history 27798 }; 27799} 27800 27801function useDeviceMotion(options = {}) { 27802 const { 27803 window = defaultWindow, 27804 requestPermissions = false, 27805 eventFilter = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.bypassFilter 27806 } = options; 27807 const isSupported = useSupported(() => typeof DeviceMotionEvent !== "undefined"); 27808 const requirePermissions = useSupported(() => isSupported.value && "requestPermission" in DeviceMotionEvent && typeof DeviceMotionEvent.requestPermission === "function"); 27809 const permissionGranted = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 27810 const acceleration = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)({ x: null, y: null, z: null }); 27811 const rotationRate = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)({ alpha: null, beta: null, gamma: null }); 27812 const interval = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 27813 const accelerationIncludingGravity = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)({ 27814 x: null, 27815 y: null, 27816 z: null 27817 }); 27818 function init() { 27819 if (window) { 27820 const onDeviceMotion = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createFilterWrapper)( 27821 eventFilter, 27822 (event) => { 27823 var _a, _b, _c, _d, _e, _f, _g, _h, _i; 27824 acceleration.value = { 27825 x: ((_a = event.acceleration) == null ? undefined : _a.x) || null, 27826 y: ((_b = event.acceleration) == null ? undefined : _b.y) || null, 27827 z: ((_c = event.acceleration) == null ? undefined : _c.z) || null 27828 }; 27829 accelerationIncludingGravity.value = { 27830 x: ((_d = event.accelerationIncludingGravity) == null ? undefined : _d.x) || null, 27831 y: ((_e = event.accelerationIncludingGravity) == null ? undefined : _e.y) || null, 27832 z: ((_f = event.accelerationIncludingGravity) == null ? undefined : _f.z) || null 27833 }; 27834 rotationRate.value = { 27835 alpha: ((_g = event.rotationRate) == null ? undefined : _g.alpha) || null, 27836 beta: ((_h = event.rotationRate) == null ? undefined : _h.beta) || null, 27837 gamma: ((_i = event.rotationRate) == null ? undefined : _i.gamma) || null 27838 }; 27839 interval.value = event.interval; 27840 } 27841 ); 27842 useEventListener(window, "devicemotion", onDeviceMotion, { passive: true }); 27843 } 27844 } 27845 const ensurePermissions = async () => { 27846 if (!requirePermissions.value) 27847 permissionGranted.value = true; 27848 if (permissionGranted.value) 27849 return; 27850 if (requirePermissions.value) { 27851 const requestPermission = DeviceMotionEvent.requestPermission; 27852 try { 27853 const response = await requestPermission(); 27854 if (response === "granted") { 27855 permissionGranted.value = true; 27856 init(); 27857 } 27858 } catch (error) { 27859 console.error(error); 27860 } 27861 } 27862 }; 27863 if (isSupported.value) { 27864 if (requestPermissions && requirePermissions.value) { 27865 ensurePermissions().then(() => init()); 27866 } else { 27867 init(); 27868 } 27869 } 27870 return { 27871 acceleration, 27872 accelerationIncludingGravity, 27873 rotationRate, 27874 interval, 27875 isSupported, 27876 requirePermissions, 27877 ensurePermissions, 27878 permissionGranted 27879 }; 27880} 27881 27882function useDeviceOrientation(options = {}) { 27883 const { window = defaultWindow } = options; 27884 const isSupported = useSupported(() => window && "DeviceOrientationEvent" in window); 27885 const isAbsolute = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 27886 const alpha = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 27887 const beta = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 27888 const gamma = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 27889 if (window && isSupported.value) { 27890 useEventListener(window, "deviceorientation", (event) => { 27891 isAbsolute.value = event.absolute; 27892 alpha.value = event.alpha; 27893 beta.value = event.beta; 27894 gamma.value = event.gamma; 27895 }, { passive: true }); 27896 } 27897 return { 27898 isSupported, 27899 isAbsolute, 27900 alpha, 27901 beta, 27902 gamma 27903 }; 27904} 27905 27906function useDevicePixelRatio(options = {}) { 27907 const { 27908 window = defaultWindow 27909 } = options; 27910 const pixelRatio = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(1); 27911 const query = useMediaQuery(() => `(resolution: ${pixelRatio.value}dppx)`, options); 27912 let stop = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop; 27913 if (window) { 27914 stop = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchImmediate)(query, () => pixelRatio.value = window.devicePixelRatio); 27915 } 27916 return { 27917 pixelRatio: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(pixelRatio), 27918 stop 27919 }; 27920} 27921 27922function useDevicesList(options = {}) { 27923 const { 27924 navigator = defaultNavigator, 27925 requestPermissions = false, 27926 constraints = { audio: true, video: true }, 27927 onUpdated 27928 } = options; 27929 const devices = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)([]); 27930 const videoInputs = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => devices.value.filter((i) => i.kind === "videoinput")); 27931 const audioInputs = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => devices.value.filter((i) => i.kind === "audioinput")); 27932 const audioOutputs = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => devices.value.filter((i) => i.kind === "audiooutput")); 27933 const isSupported = useSupported(() => navigator && navigator.mediaDevices && navigator.mediaDevices.enumerateDevices); 27934 const permissionGranted = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 27935 let stream; 27936 async function update() { 27937 if (!isSupported.value) 27938 return; 27939 devices.value = await navigator.mediaDevices.enumerateDevices(); 27940 onUpdated == null ? undefined : onUpdated(devices.value); 27941 if (stream) { 27942 stream.getTracks().forEach((t) => t.stop()); 27943 stream = null; 27944 } 27945 } 27946 async function ensurePermissions() { 27947 if (!isSupported.value) 27948 return false; 27949 if (permissionGranted.value) 27950 return true; 27951 const { state, query } = usePermission("camera", { controls: true }); 27952 await query(); 27953 if (state.value !== "granted") { 27954 let granted = true; 27955 try { 27956 stream = await navigator.mediaDevices.getUserMedia(constraints); 27957 } catch (e) { 27958 stream = null; 27959 granted = false; 27960 } 27961 update(); 27962 permissionGranted.value = granted; 27963 } else { 27964 permissionGranted.value = true; 27965 } 27966 return permissionGranted.value; 27967 } 27968 if (isSupported.value) { 27969 if (requestPermissions) 27970 ensurePermissions(); 27971 useEventListener(navigator.mediaDevices, "devicechange", update, { passive: true }); 27972 update(); 27973 } 27974 return { 27975 devices, 27976 ensurePermissions, 27977 permissionGranted, 27978 videoInputs, 27979 audioInputs, 27980 audioOutputs, 27981 isSupported 27982 }; 27983} 27984 27985function useDisplayMedia(options = {}) { 27986 var _a; 27987 const enabled = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)((_a = options.enabled) != null ? _a : false); 27988 const video = options.video; 27989 const audio = options.audio; 27990 const { navigator = defaultNavigator } = options; 27991 const isSupported = useSupported(() => { 27992 var _a2; 27993 return (_a2 = navigator == null ? undefined : navigator.mediaDevices) == null ? undefined : _a2.getDisplayMedia; 27994 }); 27995 const constraint = { audio, video }; 27996 const stream = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(); 27997 async function _start() { 27998 var _a2; 27999 if (!isSupported.value || stream.value) 28000 return; 28001 stream.value = await navigator.mediaDevices.getDisplayMedia(constraint); 28002 (_a2 = stream.value) == null ? undefined : _a2.getTracks().forEach((t) => useEventListener(t, "ended", stop, { passive: true })); 28003 return stream.value; 28004 } 28005 async function _stop() { 28006 var _a2; 28007 (_a2 = stream.value) == null ? undefined : _a2.getTracks().forEach((t) => t.stop()); 28008 stream.value = undefined; 28009 } 28010 function stop() { 28011 _stop(); 28012 enabled.value = false; 28013 } 28014 async function start() { 28015 await _start(); 28016 if (stream.value) 28017 enabled.value = true; 28018 return stream.value; 28019 } 28020 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 28021 enabled, 28022 (v) => { 28023 if (v) 28024 _start(); 28025 else 28026 _stop(); 28027 }, 28028 { immediate: true } 28029 ); 28030 return { 28031 isSupported, 28032 stream, 28033 start, 28034 stop, 28035 enabled 28036 }; 28037} 28038 28039function useDocumentVisibility(options = {}) { 28040 const { document = defaultDocument } = options; 28041 if (!document) 28042 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)("visible"); 28043 const visibility = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(document.visibilityState); 28044 useEventListener(document, "visibilitychange", () => { 28045 visibility.value = document.visibilityState; 28046 }, { passive: true }); 28047 return visibility; 28048} 28049 28050function useDraggable(target, options = {}) { 28051 var _a; 28052 const { 28053 pointerTypes, 28054 preventDefault, 28055 stopPropagation, 28056 exact, 28057 onMove, 28058 onEnd, 28059 onStart, 28060 initialValue, 28061 axis = "both", 28062 draggingElement = defaultWindow, 28063 containerElement, 28064 handle: draggingHandle = target, 28065 buttons = [0] 28066 } = options; 28067 const position = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)( 28068 (_a = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(initialValue)) != null ? _a : { x: 0, y: 0 } 28069 ); 28070 const pressedDelta = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 28071 const filterEvent = (e) => { 28072 if (pointerTypes) 28073 return pointerTypes.includes(e.pointerType); 28074 return true; 28075 }; 28076 const handleEvent = (e) => { 28077 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(preventDefault)) 28078 e.preventDefault(); 28079 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(stopPropagation)) 28080 e.stopPropagation(); 28081 }; 28082 const start = (e) => { 28083 var _a2; 28084 if (!(0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(buttons).includes(e.button)) 28085 return; 28086 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.disabled) || !filterEvent(e)) 28087 return; 28088 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(exact) && e.target !== (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target)) 28089 return; 28090 const container = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(containerElement); 28091 const containerRect = (_a2 = container == null ? undefined : container.getBoundingClientRect) == null ? undefined : _a2.call(container); 28092 const targetRect = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target).getBoundingClientRect(); 28093 const pos = { 28094 x: e.clientX - (container ? targetRect.left - containerRect.left + container.scrollLeft : targetRect.left), 28095 y: e.clientY - (container ? targetRect.top - containerRect.top + container.scrollTop : targetRect.top) 28096 }; 28097 if ((onStart == null ? undefined : onStart(pos, e)) === false) 28098 return; 28099 pressedDelta.value = pos; 28100 handleEvent(e); 28101 }; 28102 const move = (e) => { 28103 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.disabled) || !filterEvent(e)) 28104 return; 28105 if (!pressedDelta.value) 28106 return; 28107 const container = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(containerElement); 28108 const targetRect = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target).getBoundingClientRect(); 28109 let { x, y } = position.value; 28110 if (axis === "x" || axis === "both") { 28111 x = e.clientX - pressedDelta.value.x; 28112 if (container) 28113 x = Math.min(Math.max(0, x), container.scrollWidth - targetRect.width); 28114 } 28115 if (axis === "y" || axis === "both") { 28116 y = e.clientY - pressedDelta.value.y; 28117 if (container) 28118 y = Math.min(Math.max(0, y), container.scrollHeight - targetRect.height); 28119 } 28120 position.value = { 28121 x, 28122 y 28123 }; 28124 onMove == null ? undefined : onMove(position.value, e); 28125 handleEvent(e); 28126 }; 28127 const end = (e) => { 28128 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.disabled) || !filterEvent(e)) 28129 return; 28130 if (!pressedDelta.value) 28131 return; 28132 pressedDelta.value = undefined; 28133 onEnd == null ? undefined : onEnd(position.value, e); 28134 handleEvent(e); 28135 }; 28136 if (_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient) { 28137 const config = () => { 28138 var _a2; 28139 return { 28140 capture: (_a2 = options.capture) != null ? _a2 : true, 28141 passive: !(0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(preventDefault) 28142 }; 28143 }; 28144 useEventListener(draggingHandle, "pointerdown", start, config); 28145 useEventListener(draggingElement, "pointermove", move, config); 28146 useEventListener(draggingElement, "pointerup", end, config); 28147 } 28148 return { 28149 ...(0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRefs)(position), 28150 position, 28151 isDragging: (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => !!pressedDelta.value), 28152 style: (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)( 28153 () => `left:${position.value.x}px;top:${position.value.y}px;` 28154 ) 28155 }; 28156} 28157 28158function useDropZone(target, options = {}) { 28159 var _a, _b; 28160 const isOverDropZone = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 28161 const files = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(null); 28162 let counter = 0; 28163 let isValid = true; 28164 if (_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient) { 28165 const _options = typeof options === "function" ? { onDrop: options } : options; 28166 const multiple = (_a = _options.multiple) != null ? _a : true; 28167 const preventDefaultForUnhandled = (_b = _options.preventDefaultForUnhandled) != null ? _b : false; 28168 const getFiles = (event) => { 28169 var _a2, _b2; 28170 const list = Array.from((_b2 = (_a2 = event.dataTransfer) == null ? undefined : _a2.files) != null ? _b2 : []); 28171 return list.length === 0 ? null : multiple ? list : [list[0]]; 28172 }; 28173 const checkDataTypes = (types) => { 28174 const dataTypes = (0,vue__WEBPACK_IMPORTED_MODULE_1__.unref)(_options.dataTypes); 28175 if (typeof dataTypes === "function") 28176 return dataTypes(types); 28177 if (!(dataTypes == null ? undefined : dataTypes.length)) 28178 return true; 28179 if (types.length === 0) 28180 return false; 28181 return types.every( 28182 (type) => dataTypes.some((allowedType) => type.includes(allowedType)) 28183 ); 28184 }; 28185 const checkValidity = (items) => { 28186 const types = Array.from(items != null ? items : []).map((item) => item.type); 28187 const dataTypesValid = checkDataTypes(types); 28188 const multipleFilesValid = multiple || items.length <= 1; 28189 return dataTypesValid && multipleFilesValid; 28190 }; 28191 const isSafari = () => /^(?:(?!chrome|android).)*safari/i.test(navigator.userAgent) && !("chrome" in window); 28192 const handleDragEvent = (event, eventType) => { 28193 var _a2, _b2, _c, _d, _e, _f; 28194 const dataTransferItemList = (_a2 = event.dataTransfer) == null ? undefined : _a2.items; 28195 isValid = (_b2 = dataTransferItemList && checkValidity(dataTransferItemList)) != null ? _b2 : false; 28196 if (preventDefaultForUnhandled) { 28197 event.preventDefault(); 28198 } 28199 if (!isSafari() && !isValid) { 28200 if (event.dataTransfer) { 28201 event.dataTransfer.dropEffect = "none"; 28202 } 28203 return; 28204 } 28205 event.preventDefault(); 28206 if (event.dataTransfer) { 28207 event.dataTransfer.dropEffect = "copy"; 28208 } 28209 const currentFiles = getFiles(event); 28210 switch (eventType) { 28211 case "enter": 28212 counter += 1; 28213 isOverDropZone.value = true; 28214 (_c = _options.onEnter) == null ? undefined : _c.call(_options, null, event); 28215 break; 28216 case "over": 28217 (_d = _options.onOver) == null ? undefined : _d.call(_options, null, event); 28218 break; 28219 case "leave": 28220 counter -= 1; 28221 if (counter === 0) 28222 isOverDropZone.value = false; 28223 (_e = _options.onLeave) == null ? undefined : _e.call(_options, null, event); 28224 break; 28225 case "drop": 28226 counter = 0; 28227 isOverDropZone.value = false; 28228 if (isValid) { 28229 files.value = currentFiles; 28230 (_f = _options.onDrop) == null ? undefined : _f.call(_options, currentFiles, event); 28231 } 28232 break; 28233 } 28234 }; 28235 useEventListener(target, "dragenter", (event) => handleDragEvent(event, "enter")); 28236 useEventListener(target, "dragover", (event) => handleDragEvent(event, "over")); 28237 useEventListener(target, "dragleave", (event) => handleDragEvent(event, "leave")); 28238 useEventListener(target, "drop", (event) => handleDragEvent(event, "drop")); 28239 } 28240 return { 28241 files, 28242 isOverDropZone 28243 }; 28244} 28245 28246function useResizeObserver(target, callback, options = {}) { 28247 const { window = defaultWindow, ...observerOptions } = options; 28248 let observer; 28249 const isSupported = useSupported(() => window && "ResizeObserver" in window); 28250 const cleanup = () => { 28251 if (observer) { 28252 observer.disconnect(); 28253 observer = undefined; 28254 } 28255 }; 28256 const targets = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 28257 const _targets = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 28258 return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)]; 28259 }); 28260 const stopWatch = (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 28261 targets, 28262 (els) => { 28263 cleanup(); 28264 if (isSupported.value && window) { 28265 observer = new ResizeObserver(callback); 28266 for (const _el of els) { 28267 if (_el) 28268 observer.observe(_el, observerOptions); 28269 } 28270 } 28271 }, 28272 { immediate: true, flush: "post" } 28273 ); 28274 const stop = () => { 28275 cleanup(); 28276 stopWatch(); 28277 }; 28278 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(stop); 28279 return { 28280 isSupported, 28281 stop 28282 }; 28283} 28284 28285function useElementBounding(target, options = {}) { 28286 const { 28287 reset = true, 28288 windowResize = true, 28289 windowScroll = true, 28290 immediate = true, 28291 updateTiming = "sync" 28292 } = options; 28293 const height = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 28294 const bottom = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 28295 const left = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 28296 const right = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 28297 const top = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 28298 const width = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 28299 const x = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 28300 const y = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 28301 function recalculate() { 28302 const el = unrefElement(target); 28303 if (!el) { 28304 if (reset) { 28305 height.value = 0; 28306 bottom.value = 0; 28307 left.value = 0; 28308 right.value = 0; 28309 top.value = 0; 28310 width.value = 0; 28311 x.value = 0; 28312 y.value = 0; 28313 } 28314 return; 28315 } 28316 const rect = el.getBoundingClientRect(); 28317 height.value = rect.height; 28318 bottom.value = rect.bottom; 28319 left.value = rect.left; 28320 right.value = rect.right; 28321 top.value = rect.top; 28322 width.value = rect.width; 28323 x.value = rect.x; 28324 y.value = rect.y; 28325 } 28326 function update() { 28327 if (updateTiming === "sync") 28328 recalculate(); 28329 else if (updateTiming === "next-frame") 28330 requestAnimationFrame(() => recalculate()); 28331 } 28332 useResizeObserver(target, update); 28333 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(() => unrefElement(target), (ele) => !ele && update()); 28334 useMutationObserver(target, update, { 28335 attributeFilter: ["style", "class"] 28336 }); 28337 if (windowScroll) 28338 useEventListener("scroll", update, { capture: true, passive: true }); 28339 if (windowResize) 28340 useEventListener("resize", update, { passive: true }); 28341 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => { 28342 if (immediate) 28343 update(); 28344 }); 28345 return { 28346 height, 28347 bottom, 28348 left, 28349 right, 28350 top, 28351 width, 28352 x, 28353 y, 28354 update 28355 }; 28356} 28357 28358function useElementByPoint(options) { 28359 const { 28360 x, 28361 y, 28362 document = defaultDocument, 28363 multiple, 28364 interval = "requestAnimationFrame", 28365 immediate = true 28366 } = options; 28367 const isSupported = useSupported(() => { 28368 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(multiple)) 28369 return document && "elementsFromPoint" in document; 28370 return document && "elementFromPoint" in document; 28371 }); 28372 const element = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 28373 const cb = () => { 28374 var _a, _b; 28375 element.value = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(multiple) ? (_a = document == null ? undefined : document.elementsFromPoint((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(x), (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(y))) != null ? _a : [] : (_b = document == null ? undefined : document.elementFromPoint((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(x), (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(y))) != null ? _b : null; 28376 }; 28377 const controls = interval === "requestAnimationFrame" ? useRafFn(cb, { immediate }) : (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useIntervalFn)(cb, interval, { immediate }); 28378 return { 28379 isSupported, 28380 element, 28381 ...controls 28382 }; 28383} 28384 28385function useElementHover(el, options = {}) { 28386 const { 28387 delayEnter = 0, 28388 delayLeave = 0, 28389 triggerOnRemoval = false, 28390 window = defaultWindow 28391 } = options; 28392 const isHovered = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 28393 let timer; 28394 const toggle = (entering) => { 28395 const delay = entering ? delayEnter : delayLeave; 28396 if (timer) { 28397 clearTimeout(timer); 28398 timer = undefined; 28399 } 28400 if (delay) 28401 timer = setTimeout(() => isHovered.value = entering, delay); 28402 else 28403 isHovered.value = entering; 28404 }; 28405 if (!window) 28406 return isHovered; 28407 useEventListener(el, "mouseenter", () => toggle(true), { passive: true }); 28408 useEventListener(el, "mouseleave", () => toggle(false), { passive: true }); 28409 if (triggerOnRemoval) { 28410 onElementRemoval( 28411 (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => unrefElement(el)), 28412 () => toggle(false) 28413 ); 28414 } 28415 return isHovered; 28416} 28417 28418function useElementSize(target, initialSize = { width: 0, height: 0 }, options = {}) { 28419 const { window = defaultWindow, box = "content-box" } = options; 28420 const isSVG = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 28421 var _a, _b; 28422 return (_b = (_a = unrefElement(target)) == null ? undefined : _a.namespaceURI) == null ? undefined : _b.includes("svg"); 28423 }); 28424 const width = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialSize.width); 28425 const height = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialSize.height); 28426 const { stop: stop1 } = useResizeObserver( 28427 target, 28428 ([entry]) => { 28429 const boxSize = box === "border-box" ? entry.borderBoxSize : box === "content-box" ? entry.contentBoxSize : entry.devicePixelContentBoxSize; 28430 if (window && isSVG.value) { 28431 const $elem = unrefElement(target); 28432 if ($elem) { 28433 const rect = $elem.getBoundingClientRect(); 28434 width.value = rect.width; 28435 height.value = rect.height; 28436 } 28437 } else { 28438 if (boxSize) { 28439 const formatBoxSize = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(boxSize); 28440 width.value = formatBoxSize.reduce((acc, { inlineSize }) => acc + inlineSize, 0); 28441 height.value = formatBoxSize.reduce((acc, { blockSize }) => acc + blockSize, 0); 28442 } else { 28443 width.value = entry.contentRect.width; 28444 height.value = entry.contentRect.height; 28445 } 28446 } 28447 }, 28448 options 28449 ); 28450 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => { 28451 const ele = unrefElement(target); 28452 if (ele) { 28453 width.value = "offsetWidth" in ele ? ele.offsetWidth : initialSize.width; 28454 height.value = "offsetHeight" in ele ? ele.offsetHeight : initialSize.height; 28455 } 28456 }); 28457 const stop2 = (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 28458 () => unrefElement(target), 28459 (ele) => { 28460 width.value = ele ? initialSize.width : 0; 28461 height.value = ele ? initialSize.height : 0; 28462 } 28463 ); 28464 function stop() { 28465 stop1(); 28466 stop2(); 28467 } 28468 return { 28469 width, 28470 height, 28471 stop 28472 }; 28473} 28474 28475function useIntersectionObserver(target, callback, options = {}) { 28476 const { 28477 root, 28478 rootMargin = "0px", 28479 threshold = 0, 28480 window = defaultWindow, 28481 immediate = true 28482 } = options; 28483 const isSupported = useSupported(() => window && "IntersectionObserver" in window); 28484 const targets = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 28485 const _target = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 28486 return (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toArray)(_target).map(unrefElement).filter(_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.notNullish); 28487 }); 28488 let cleanup = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop; 28489 const isActive = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(immediate); 28490 const stopWatch = isSupported.value ? (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 28491 () => [targets.value, unrefElement(root), isActive.value], 28492 ([targets2, root2]) => { 28493 cleanup(); 28494 if (!isActive.value) 28495 return; 28496 if (!targets2.length) 28497 return; 28498 const observer = new IntersectionObserver( 28499 callback, 28500 { 28501 root: unrefElement(root2), 28502 rootMargin, 28503 threshold 28504 } 28505 ); 28506 targets2.forEach((el) => el && observer.observe(el)); 28507 cleanup = () => { 28508 observer.disconnect(); 28509 cleanup = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop; 28510 }; 28511 }, 28512 { immediate, flush: "post" } 28513 ) : _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop; 28514 const stop = () => { 28515 cleanup(); 28516 stopWatch(); 28517 isActive.value = false; 28518 }; 28519 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(stop); 28520 return { 28521 isSupported, 28522 isActive, 28523 pause() { 28524 cleanup(); 28525 isActive.value = false; 28526 }, 28527 resume() { 28528 isActive.value = true; 28529 }, 28530 stop 28531 }; 28532} 28533 28534function useElementVisibility(element, options = {}) { 28535 const { 28536 window = defaultWindow, 28537 scrollTarget, 28538 threshold = 0, 28539 rootMargin 28540 } = options; 28541 const elementIsVisible = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 28542 useIntersectionObserver( 28543 element, 28544 (intersectionObserverEntries) => { 28545 let isIntersecting = elementIsVisible.value; 28546 let latestTime = 0; 28547 for (const entry of intersectionObserverEntries) { 28548 if (entry.time >= latestTime) { 28549 latestTime = entry.time; 28550 isIntersecting = entry.isIntersecting; 28551 } 28552 } 28553 elementIsVisible.value = isIntersecting; 28554 }, 28555 { 28556 root: scrollTarget, 28557 window, 28558 threshold, 28559 rootMargin: (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(rootMargin) 28560 } 28561 ); 28562 return elementIsVisible; 28563} 28564 28565const events = /* @__PURE__ */ new Map(); 28566 28567function useEventBus(key) { 28568 const scope = (0,vue__WEBPACK_IMPORTED_MODULE_1__.getCurrentScope)(); 28569 function on(listener) { 28570 var _a; 28571 const listeners = events.get(key) || /* @__PURE__ */ new Set(); 28572 listeners.add(listener); 28573 events.set(key, listeners); 28574 const _off = () => off(listener); 28575 (_a = scope == null ? undefined : scope.cleanups) == null ? undefined : _a.push(_off); 28576 return _off; 28577 } 28578 function once(listener) { 28579 function _listener(...args) { 28580 off(_listener); 28581 listener(...args); 28582 } 28583 return on(_listener); 28584 } 28585 function off(listener) { 28586 const listeners = events.get(key); 28587 if (!listeners) 28588 return; 28589 listeners.delete(listener); 28590 if (!listeners.size) 28591 reset(); 28592 } 28593 function reset() { 28594 events.delete(key); 28595 } 28596 function emit(event, payload) { 28597 var _a; 28598 (_a = events.get(key)) == null ? undefined : _a.forEach((v) => v(event, payload)); 28599 } 28600 return { on, once, off, emit, reset }; 28601} 28602 28603function resolveNestedOptions$1(options) { 28604 if (options === true) 28605 return {}; 28606 return options; 28607} 28608function useEventSource(url, events = [], options = {}) { 28609 const event = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 28610 const data = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 28611 const status = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)("CONNECTING"); 28612 const eventSource = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 28613 const error = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(null); 28614 const urlRef = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(url); 28615 const lastEventId = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(null); 28616 let explicitlyClosed = false; 28617 let retried = 0; 28618 const { 28619 withCredentials = false, 28620 immediate = true, 28621 autoConnect = true, 28622 autoReconnect 28623 } = options; 28624 const close = () => { 28625 if (_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient && eventSource.value) { 28626 eventSource.value.close(); 28627 eventSource.value = null; 28628 status.value = "CLOSED"; 28629 explicitlyClosed = true; 28630 } 28631 }; 28632 const _init = () => { 28633 if (explicitlyClosed || typeof urlRef.value === "undefined") 28634 return; 28635 const es = new EventSource(urlRef.value, { withCredentials }); 28636 status.value = "CONNECTING"; 28637 eventSource.value = es; 28638 es.onopen = () => { 28639 status.value = "OPEN"; 28640 error.value = null; 28641 }; 28642 es.onerror = (e) => { 28643 status.value = "CLOSED"; 28644 error.value = e; 28645 if (es.readyState === 2 && !explicitlyClosed && autoReconnect) { 28646 es.close(); 28647 const { 28648 retries = -1, 28649 delay = 1e3, 28650 onFailed 28651 } = resolveNestedOptions$1(autoReconnect); 28652 retried += 1; 28653 if (typeof retries === "number" && (retries < 0 || retried < retries)) 28654 setTimeout(_init, delay); 28655 else if (typeof retries === "function" && retries()) 28656 setTimeout(_init, delay); 28657 else 28658 onFailed == null ? undefined : onFailed(); 28659 } 28660 }; 28661 es.onmessage = (e) => { 28662 event.value = null; 28663 data.value = e.data; 28664 lastEventId.value = e.lastEventId; 28665 }; 28666 for (const event_name of events) { 28667 useEventListener(es, event_name, (e) => { 28668 event.value = event_name; 28669 data.value = e.data || null; 28670 }, { passive: true }); 28671 } 28672 }; 28673 const open = () => { 28674 if (!_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient) 28675 return; 28676 close(); 28677 explicitlyClosed = false; 28678 retried = 0; 28679 _init(); 28680 }; 28681 if (immediate) 28682 open(); 28683 if (autoConnect) 28684 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(urlRef, open); 28685 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(close); 28686 return { 28687 eventSource, 28688 event, 28689 data, 28690 status, 28691 error, 28692 open, 28693 close, 28694 lastEventId 28695 }; 28696} 28697 28698function useEyeDropper(options = {}) { 28699 const { initialValue = "" } = options; 28700 const isSupported = useSupported(() => typeof window !== "undefined" && "EyeDropper" in window); 28701 const sRGBHex = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialValue); 28702 async function open(openOptions) { 28703 if (!isSupported.value) 28704 return; 28705 const eyeDropper = new window.EyeDropper(); 28706 const result = await eyeDropper.open(openOptions); 28707 sRGBHex.value = result.sRGBHex; 28708 return result; 28709 } 28710 return { isSupported, sRGBHex, open }; 28711} 28712 28713function useFavicon(newIcon = null, options = {}) { 28714 const { 28715 baseUrl = "", 28716 rel = "icon", 28717 document = defaultDocument 28718 } = options; 28719 const favicon = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(newIcon); 28720 const applyIcon = (icon) => { 28721 const elements = document == null ? undefined : document.head.querySelectorAll(`link[rel*="${rel}"]`); 28722 if (!elements || elements.length === 0) { 28723 const link = document == null ? undefined : document.createElement("link"); 28724 if (link) { 28725 link.rel = rel; 28726 link.href = `${baseUrl}${icon}`; 28727 link.type = `image/${icon.split(".").pop()}`; 28728 document == null ? undefined : document.head.append(link); 28729 } 28730 return; 28731 } 28732 elements == null ? undefined : elements.forEach((el) => el.href = `${baseUrl}${icon}`); 28733 }; 28734 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 28735 favicon, 28736 (i, o) => { 28737 if (typeof i === "string" && i !== o) 28738 applyIcon(i); 28739 }, 28740 { immediate: true } 28741 ); 28742 return favicon; 28743} 28744 28745const payloadMapping = { 28746 json: "application/json", 28747 text: "text/plain" 28748}; 28749function isFetchOptions(obj) { 28750 return obj && (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.containsProp)(obj, "immediate", "refetch", "initialData", "timeout", "beforeFetch", "afterFetch", "onFetchError", "fetch", "updateDataOnError"); 28751} 28752const reAbsolute = /^(?:[a-z][a-z\d+\-.]*:)?\/\//i; 28753function isAbsoluteURL(url) { 28754 return reAbsolute.test(url); 28755} 28756function headersToObject(headers) { 28757 if (typeof Headers !== "undefined" && headers instanceof Headers) 28758 return Object.fromEntries(headers.entries()); 28759 return headers; 28760} 28761function combineCallbacks(combination, ...callbacks) { 28762 if (combination === "overwrite") { 28763 return async (ctx) => { 28764 const callback = callbacks[callbacks.length - 1]; 28765 if (callback) 28766 return { ...ctx, ...await callback(ctx) }; 28767 return ctx; 28768 }; 28769 } else { 28770 return async (ctx) => { 28771 for (const callback of callbacks) { 28772 if (callback) 28773 ctx = { ...ctx, ...await callback(ctx) }; 28774 } 28775 return ctx; 28776 }; 28777 } 28778} 28779function createFetch(config = {}) { 28780 const _combination = config.combination || "chain"; 28781 const _options = config.options || {}; 28782 const _fetchOptions = config.fetchOptions || {}; 28783 function useFactoryFetch(url, ...args) { 28784 const computedUrl = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 28785 const baseUrl = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(config.baseUrl); 28786 const targetUrl = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(url); 28787 return baseUrl && !isAbsoluteURL(targetUrl) ? joinPaths(baseUrl, targetUrl) : targetUrl; 28788 }); 28789 let options = _options; 28790 let fetchOptions = _fetchOptions; 28791 if (args.length > 0) { 28792 if (isFetchOptions(args[0])) { 28793 options = { 28794 ...options, 28795 ...args[0], 28796 beforeFetch: combineCallbacks(_combination, _options.beforeFetch, args[0].beforeFetch), 28797 afterFetch: combineCallbacks(_combination, _options.afterFetch, args[0].afterFetch), 28798 onFetchError: combineCallbacks(_combination, _options.onFetchError, args[0].onFetchError) 28799 }; 28800 } else { 28801 fetchOptions = { 28802 ...fetchOptions, 28803 ...args[0], 28804 headers: { 28805 ...headersToObject(fetchOptions.headers) || {}, 28806 ...headersToObject(args[0].headers) || {} 28807 } 28808 }; 28809 } 28810 } 28811 if (args.length > 1 && isFetchOptions(args[1])) { 28812 options = { 28813 ...options, 28814 ...args[1], 28815 beforeFetch: combineCallbacks(_combination, _options.beforeFetch, args[1].beforeFetch), 28816 afterFetch: combineCallbacks(_combination, _options.afterFetch, args[1].afterFetch), 28817 onFetchError: combineCallbacks(_combination, _options.onFetchError, args[1].onFetchError) 28818 }; 28819 } 28820 return useFetch(computedUrl, fetchOptions, options); 28821 } 28822 return useFactoryFetch; 28823} 28824function useFetch(url, ...args) { 28825 var _a; 28826 const supportsAbort = typeof AbortController === "function"; 28827 let fetchOptions = {}; 28828 let options = { 28829 immediate: true, 28830 refetch: false, 28831 timeout: 0, 28832 updateDataOnError: false 28833 }; 28834 const config = { 28835 method: "GET", 28836 type: "text", 28837 payload: undefined 28838 }; 28839 if (args.length > 0) { 28840 if (isFetchOptions(args[0])) 28841 options = { ...options, ...args[0] }; 28842 else 28843 fetchOptions = args[0]; 28844 } 28845 if (args.length > 1) { 28846 if (isFetchOptions(args[1])) 28847 options = { ...options, ...args[1] }; 28848 } 28849 const { 28850 fetch = (_a = defaultWindow) == null ? undefined : _a.fetch, 28851 initialData, 28852 timeout 28853 } = options; 28854 const responseEvent = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 28855 const errorEvent = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 28856 const finallyEvent = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 28857 const isFinished = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 28858 const isFetching = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 28859 const aborted = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 28860 const statusCode = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 28861 const response = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(null); 28862 const error = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(null); 28863 const data = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(initialData || null); 28864 const canAbort = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => supportsAbort && isFetching.value); 28865 let controller; 28866 let timer; 28867 const abort = () => { 28868 if (supportsAbort) { 28869 controller == null ? undefined : controller.abort(); 28870 controller = new AbortController(); 28871 controller.signal.onabort = () => aborted.value = true; 28872 fetchOptions = { 28873 ...fetchOptions, 28874 signal: controller.signal 28875 }; 28876 } 28877 }; 28878 const loading = (isLoading) => { 28879 isFetching.value = isLoading; 28880 isFinished.value = !isLoading; 28881 }; 28882 if (timeout) 28883 timer = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useTimeoutFn)(abort, timeout, { immediate: false }); 28884 let executeCounter = 0; 28885 const execute = async (throwOnFailed = false) => { 28886 var _a2, _b; 28887 abort(); 28888 loading(true); 28889 error.value = null; 28890 statusCode.value = null; 28891 aborted.value = false; 28892 executeCounter += 1; 28893 const currentExecuteCounter = executeCounter; 28894 const defaultFetchOptions = { 28895 method: config.method, 28896 headers: {} 28897 }; 28898 const payload = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(config.payload); 28899 if (payload) { 28900 const headers = headersToObject(defaultFetchOptions.headers); 28901 const proto = Object.getPrototypeOf(payload); 28902 if (!config.payloadType && payload && (proto === Object.prototype || Array.isArray(proto)) && !(payload instanceof FormData)) 28903 config.payloadType = "json"; 28904 if (config.payloadType) 28905 headers["Content-Type"] = (_a2 = payloadMapping[config.payloadType]) != null ? _a2 : config.payloadType; 28906 defaultFetchOptions.body = config.payloadType === "json" ? JSON.stringify(payload) : payload; 28907 } 28908 let isCanceled = false; 28909 const context = { 28910 url: (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(url), 28911 options: { 28912 ...defaultFetchOptions, 28913 ...fetchOptions 28914 }, 28915 cancel: () => { 28916 isCanceled = true; 28917 } 28918 }; 28919 if (options.beforeFetch) 28920 Object.assign(context, await options.beforeFetch(context)); 28921 if (isCanceled || !fetch) { 28922 loading(false); 28923 return Promise.resolve(null); 28924 } 28925 let responseData = null; 28926 if (timer) 28927 timer.start(); 28928 return fetch( 28929 context.url, 28930 { 28931 ...defaultFetchOptions, 28932 ...context.options, 28933 headers: { 28934 ...headersToObject(defaultFetchOptions.headers), 28935 ...headersToObject((_b = context.options) == null ? undefined : _b.headers) 28936 } 28937 } 28938 ).then(async (fetchResponse) => { 28939 response.value = fetchResponse; 28940 statusCode.value = fetchResponse.status; 28941 responseData = await fetchResponse.clone()[config.type](); 28942 if (!fetchResponse.ok) { 28943 data.value = initialData || null; 28944 throw new Error(fetchResponse.statusText); 28945 } 28946 if (options.afterFetch) { 28947 ({ data: responseData } = await options.afterFetch({ 28948 data: responseData, 28949 response: fetchResponse, 28950 context, 28951 execute 28952 })); 28953 } 28954 data.value = responseData; 28955 responseEvent.trigger(fetchResponse); 28956 return fetchResponse; 28957 }).catch(async (fetchError) => { 28958 let errorData = fetchError.message || fetchError.name; 28959 if (options.onFetchError) { 28960 ({ error: errorData, data: responseData } = await options.onFetchError({ 28961 data: responseData, 28962 error: fetchError, 28963 response: response.value, 28964 context, 28965 execute 28966 })); 28967 } 28968 error.value = errorData; 28969 if (options.updateDataOnError) 28970 data.value = responseData; 28971 errorEvent.trigger(fetchError); 28972 if (throwOnFailed) 28973 throw fetchError; 28974 return null; 28975 }).finally(() => { 28976 if (currentExecuteCounter === executeCounter) 28977 loading(false); 28978 if (timer) 28979 timer.stop(); 28980 finallyEvent.trigger(null); 28981 }); 28982 }; 28983 const refetch = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(options.refetch); 28984 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 28985 [ 28986 refetch, 28987 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(url) 28988 ], 28989 ([refetch2]) => refetch2 && execute(), 28990 { deep: true } 28991 ); 28992 const shell = { 28993 isFinished: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(isFinished), 28994 isFetching: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(isFetching), 28995 statusCode, 28996 response, 28997 error, 28998 data, 28999 canAbort, 29000 aborted, 29001 abort, 29002 execute, 29003 onFetchResponse: responseEvent.on, 29004 onFetchError: errorEvent.on, 29005 onFetchFinally: finallyEvent.on, 29006 // method 29007 get: setMethod("GET"), 29008 put: setMethod("PUT"), 29009 post: setMethod("POST"), 29010 delete: setMethod("DELETE"), 29011 patch: setMethod("PATCH"), 29012 head: setMethod("HEAD"), 29013 options: setMethod("OPTIONS"), 29014 // type 29015 json: setType("json"), 29016 text: setType("text"), 29017 blob: setType("blob"), 29018 arrayBuffer: setType("arrayBuffer"), 29019 formData: setType("formData") 29020 }; 29021 function setMethod(method) { 29022 return (payload, payloadType) => { 29023 if (!isFetching.value) { 29024 config.method = method; 29025 config.payload = payload; 29026 config.payloadType = payloadType; 29027 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.isRef)(config.payload)) { 29028 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 29029 [ 29030 refetch, 29031 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(config.payload) 29032 ], 29033 ([refetch2]) => refetch2 && execute(), 29034 { deep: true } 29035 ); 29036 } 29037 return { 29038 ...shell, 29039 then(onFulfilled, onRejected) { 29040 return waitUntilFinished().then(onFulfilled, onRejected); 29041 } 29042 }; 29043 } 29044 return undefined; 29045 }; 29046 } 29047 function waitUntilFinished() { 29048 return new Promise((resolve, reject) => { 29049 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.until)(isFinished).toBe(true).then(() => resolve(shell)).catch(reject); 29050 }); 29051 } 29052 function setType(type) { 29053 return () => { 29054 if (!isFetching.value) { 29055 config.type = type; 29056 return { 29057 ...shell, 29058 then(onFulfilled, onRejected) { 29059 return waitUntilFinished().then(onFulfilled, onRejected); 29060 } 29061 }; 29062 } 29063 return undefined; 29064 }; 29065 } 29066 if (options.immediate) 29067 Promise.resolve().then(() => execute()); 29068 return { 29069 ...shell, 29070 then(onFulfilled, onRejected) { 29071 return waitUntilFinished().then(onFulfilled, onRejected); 29072 } 29073 }; 29074} 29075function joinPaths(start, end) { 29076 if (!start.endsWith("/") && !end.startsWith("/")) { 29077 return `${start}/${end}`; 29078 } 29079 if (start.endsWith("/") && end.startsWith("/")) { 29080 return `${start.slice(0, -1)}${end}`; 29081 } 29082 return `${start}${end}`; 29083} 29084 29085const DEFAULT_OPTIONS = { 29086 multiple: true, 29087 accept: "*", 29088 reset: false, 29089 directory: false 29090}; 29091function prepareInitialFiles(files) { 29092 if (!files) 29093 return null; 29094 if (files instanceof FileList) 29095 return files; 29096 const dt = new DataTransfer(); 29097 for (const file of files) { 29098 dt.items.add(file); 29099 } 29100 return dt.files; 29101} 29102function useFileDialog(options = {}) { 29103 const { 29104 document = defaultDocument 29105 } = options; 29106 const files = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(prepareInitialFiles(options.initialFiles)); 29107 const { on: onChange, trigger: changeTrigger } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 29108 const { on: onCancel, trigger: cancelTrigger } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 29109 let input; 29110 if (document) { 29111 input = document.createElement("input"); 29112 input.type = "file"; 29113 input.onchange = (event) => { 29114 const result = event.target; 29115 files.value = result.files; 29116 changeTrigger(files.value); 29117 }; 29118 input.oncancel = () => { 29119 cancelTrigger(); 29120 }; 29121 } 29122 const reset = () => { 29123 files.value = null; 29124 if (input && input.value) { 29125 input.value = ""; 29126 changeTrigger(null); 29127 } 29128 }; 29129 const open = (localOptions) => { 29130 if (!input) 29131 return; 29132 const _options = { 29133 ...DEFAULT_OPTIONS, 29134 ...options, 29135 ...localOptions 29136 }; 29137 input.multiple = _options.multiple; 29138 input.accept = _options.accept; 29139 input.webkitdirectory = _options.directory; 29140 if ((0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(_options, "capture")) 29141 input.capture = _options.capture; 29142 if (_options.reset) 29143 reset(); 29144 input.click(); 29145 }; 29146 return { 29147 files: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(files), 29148 open, 29149 reset, 29150 onCancel, 29151 onChange 29152 }; 29153} 29154 29155function useFileSystemAccess(options = {}) { 29156 const { 29157 window: _window = defaultWindow, 29158 dataType = "Text" 29159 } = options; 29160 const window = _window; 29161 const isSupported = useSupported(() => window && "showSaveFilePicker" in window && "showOpenFilePicker" in window); 29162 const fileHandle = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 29163 const data = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 29164 const file = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 29165 const fileName = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 29166 var _a, _b; 29167 return (_b = (_a = file.value) == null ? undefined : _a.name) != null ? _b : ""; 29168 }); 29169 const fileMIME = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 29170 var _a, _b; 29171 return (_b = (_a = file.value) == null ? undefined : _a.type) != null ? _b : ""; 29172 }); 29173 const fileSize = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 29174 var _a, _b; 29175 return (_b = (_a = file.value) == null ? undefined : _a.size) != null ? _b : 0; 29176 }); 29177 const fileLastModified = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 29178 var _a, _b; 29179 return (_b = (_a = file.value) == null ? undefined : _a.lastModified) != null ? _b : 0; 29180 }); 29181 async function open(_options = {}) { 29182 if (!isSupported.value) 29183 return; 29184 const [handle] = await window.showOpenFilePicker({ ...(0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options), ..._options }); 29185 fileHandle.value = handle; 29186 await updateData(); 29187 } 29188 async function create(_options = {}) { 29189 if (!isSupported.value) 29190 return; 29191 fileHandle.value = await window.showSaveFilePicker({ ...options, ..._options }); 29192 data.value = undefined; 29193 await updateData(); 29194 } 29195 async function save(_options = {}) { 29196 if (!isSupported.value) 29197 return; 29198 if (!fileHandle.value) 29199 return saveAs(_options); 29200 if (data.value) { 29201 const writableStream = await fileHandle.value.createWritable(); 29202 await writableStream.write(data.value); 29203 await writableStream.close(); 29204 } 29205 await updateFile(); 29206 } 29207 async function saveAs(_options = {}) { 29208 if (!isSupported.value) 29209 return; 29210 fileHandle.value = await window.showSaveFilePicker({ ...options, ..._options }); 29211 if (data.value) { 29212 const writableStream = await fileHandle.value.createWritable(); 29213 await writableStream.write(data.value); 29214 await writableStream.close(); 29215 } 29216 await updateFile(); 29217 } 29218 async function updateFile() { 29219 var _a; 29220 file.value = await ((_a = fileHandle.value) == null ? undefined : _a.getFile()); 29221 } 29222 async function updateData() { 29223 var _a, _b; 29224 await updateFile(); 29225 const type = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(dataType); 29226 if (type === "Text") 29227 data.value = await ((_a = file.value) == null ? undefined : _a.text()); 29228 else if (type === "ArrayBuffer") 29229 data.value = await ((_b = file.value) == null ? undefined : _b.arrayBuffer()); 29230 else if (type === "Blob") 29231 data.value = file.value; 29232 } 29233 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(() => (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(dataType), updateData); 29234 return { 29235 isSupported, 29236 data, 29237 file, 29238 fileName, 29239 fileMIME, 29240 fileSize, 29241 fileLastModified, 29242 open, 29243 create, 29244 save, 29245 saveAs, 29246 updateData 29247 }; 29248} 29249 29250function useFocus(target, options = {}) { 29251 const { initialValue = false, focusVisible = false, preventScroll = false } = options; 29252 const innerFocused = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 29253 const targetElement = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => unrefElement(target)); 29254 const listenerOptions = { passive: true }; 29255 useEventListener(targetElement, "focus", (event) => { 29256 var _a, _b; 29257 if (!focusVisible || ((_b = (_a = event.target).matches) == null ? undefined : _b.call(_a, ":focus-visible"))) 29258 innerFocused.value = true; 29259 }, listenerOptions); 29260 useEventListener(targetElement, "blur", () => innerFocused.value = false, listenerOptions); 29261 const focused = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 29262 get: () => innerFocused.value, 29263 set(value) { 29264 var _a, _b; 29265 if (!value && innerFocused.value) 29266 (_a = targetElement.value) == null ? undefined : _a.blur(); 29267 else if (value && !innerFocused.value) 29268 (_b = targetElement.value) == null ? undefined : _b.focus({ preventScroll }); 29269 } 29270 }); 29271 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 29272 targetElement, 29273 () => { 29274 focused.value = initialValue; 29275 }, 29276 { immediate: true, flush: "post" } 29277 ); 29278 return { focused }; 29279} 29280 29281const EVENT_FOCUS_IN = "focusin"; 29282const EVENT_FOCUS_OUT = "focusout"; 29283const PSEUDO_CLASS_FOCUS_WITHIN = ":focus-within"; 29284function useFocusWithin(target, options = {}) { 29285 const { window = defaultWindow } = options; 29286 const targetElement = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => unrefElement(target)); 29287 const _focused = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 29288 const focused = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => _focused.value); 29289 const activeElement = useActiveElement(options); 29290 if (!window || !activeElement.value) { 29291 return { focused }; 29292 } 29293 const listenerOptions = { passive: true }; 29294 useEventListener(targetElement, EVENT_FOCUS_IN, () => _focused.value = true, listenerOptions); 29295 useEventListener(targetElement, EVENT_FOCUS_OUT, () => { 29296 var _a, _b, _c; 29297 return _focused.value = (_c = (_b = (_a = targetElement.value) == null ? undefined : _a.matches) == null ? undefined : _b.call(_a, PSEUDO_CLASS_FOCUS_WITHIN)) != null ? _c : false; 29298 }, listenerOptions); 29299 return { focused }; 29300} 29301 29302function useFps(options) { 29303 var _a; 29304 const fps = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 29305 if (typeof performance === "undefined") 29306 return fps; 29307 const every = (_a = options == null ? undefined : options.every) != null ? _a : 10; 29308 let last = performance.now(); 29309 let ticks = 0; 29310 useRafFn(() => { 29311 ticks += 1; 29312 if (ticks >= every) { 29313 const now = performance.now(); 29314 const diff = now - last; 29315 fps.value = Math.round(1e3 / (diff / ticks)); 29316 last = now; 29317 ticks = 0; 29318 } 29319 }); 29320 return fps; 29321} 29322 29323const eventHandlers = [ 29324 "fullscreenchange", 29325 "webkitfullscreenchange", 29326 "webkitendfullscreen", 29327 "mozfullscreenchange", 29328 "MSFullscreenChange" 29329]; 29330function useFullscreen(target, options = {}) { 29331 const { 29332 document = defaultDocument, 29333 autoExit = false 29334 } = options; 29335 const targetRef = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 29336 var _a; 29337 return (_a = unrefElement(target)) != null ? _a : document == null ? undefined : document.querySelector("html"); 29338 }); 29339 const isFullscreen = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 29340 const requestMethod = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 29341 return [ 29342 "requestFullscreen", 29343 "webkitRequestFullscreen", 29344 "webkitEnterFullscreen", 29345 "webkitEnterFullScreen", 29346 "webkitRequestFullScreen", 29347 "mozRequestFullScreen", 29348 "msRequestFullscreen" 29349 ].find((m) => document && m in document || targetRef.value && m in targetRef.value); 29350 }); 29351 const exitMethod = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 29352 return [ 29353 "exitFullscreen", 29354 "webkitExitFullscreen", 29355 "webkitExitFullScreen", 29356 "webkitCancelFullScreen", 29357 "mozCancelFullScreen", 29358 "msExitFullscreen" 29359 ].find((m) => document && m in document || targetRef.value && m in targetRef.value); 29360 }); 29361 const fullscreenEnabled = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 29362 return [ 29363 "fullScreen", 29364 "webkitIsFullScreen", 29365 "webkitDisplayingFullscreen", 29366 "mozFullScreen", 29367 "msFullscreenElement" 29368 ].find((m) => document && m in document || targetRef.value && m in targetRef.value); 29369 }); 29370 const fullscreenElementMethod = [ 29371 "fullscreenElement", 29372 "webkitFullscreenElement", 29373 "mozFullScreenElement", 29374 "msFullscreenElement" 29375 ].find((m) => document && m in document); 29376 const isSupported = useSupported(() => targetRef.value && document && requestMethod.value !== undefined && exitMethod.value !== undefined && fullscreenEnabled.value !== undefined); 29377 const isCurrentElementFullScreen = () => { 29378 if (fullscreenElementMethod) 29379 return (document == null ? undefined : document[fullscreenElementMethod]) === targetRef.value; 29380 return false; 29381 }; 29382 const isElementFullScreen = () => { 29383 if (fullscreenEnabled.value) { 29384 if (document && document[fullscreenEnabled.value] != null) { 29385 return document[fullscreenEnabled.value]; 29386 } else { 29387 const target2 = targetRef.value; 29388 if ((target2 == null ? undefined : target2[fullscreenEnabled.value]) != null) { 29389 return Boolean(target2[fullscreenEnabled.value]); 29390 } 29391 } 29392 } 29393 return false; 29394 }; 29395 async function exit() { 29396 if (!isSupported.value || !isFullscreen.value) 29397 return; 29398 if (exitMethod.value) { 29399 if ((document == null ? undefined : document[exitMethod.value]) != null) { 29400 await document[exitMethod.value](); 29401 } else { 29402 const target2 = targetRef.value; 29403 if ((target2 == null ? undefined : target2[exitMethod.value]) != null) 29404 await target2[exitMethod.value](); 29405 } 29406 } 29407 isFullscreen.value = false; 29408 } 29409 async function enter() { 29410 if (!isSupported.value || isFullscreen.value) 29411 return; 29412 if (isElementFullScreen()) 29413 await exit(); 29414 const target2 = targetRef.value; 29415 if (requestMethod.value && (target2 == null ? undefined : target2[requestMethod.value]) != null) { 29416 await target2[requestMethod.value](); 29417 isFullscreen.value = true; 29418 } 29419 } 29420 async function toggle() { 29421 await (isFullscreen.value ? exit() : enter()); 29422 } 29423 const handlerCallback = () => { 29424 const isElementFullScreenValue = isElementFullScreen(); 29425 if (!isElementFullScreenValue || isElementFullScreenValue && isCurrentElementFullScreen()) 29426 isFullscreen.value = isElementFullScreenValue; 29427 }; 29428 const listenerOptions = { capture: false, passive: true }; 29429 useEventListener(document, eventHandlers, handlerCallback, listenerOptions); 29430 useEventListener(() => unrefElement(targetRef), eventHandlers, handlerCallback, listenerOptions); 29431 if (autoExit) 29432 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(exit); 29433 return { 29434 isSupported, 29435 isFullscreen, 29436 enter, 29437 exit, 29438 toggle 29439 }; 29440} 29441 29442function mapGamepadToXbox360Controller(gamepad) { 29443 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 29444 if (gamepad.value) { 29445 return { 29446 buttons: { 29447 a: gamepad.value.buttons[0], 29448 b: gamepad.value.buttons[1], 29449 x: gamepad.value.buttons[2], 29450 y: gamepad.value.buttons[3] 29451 }, 29452 bumper: { 29453 left: gamepad.value.buttons[4], 29454 right: gamepad.value.buttons[5] 29455 }, 29456 triggers: { 29457 left: gamepad.value.buttons[6], 29458 right: gamepad.value.buttons[7] 29459 }, 29460 stick: { 29461 left: { 29462 horizontal: gamepad.value.axes[0], 29463 vertical: gamepad.value.axes[1], 29464 button: gamepad.value.buttons[10] 29465 }, 29466 right: { 29467 horizontal: gamepad.value.axes[2], 29468 vertical: gamepad.value.axes[3], 29469 button: gamepad.value.buttons[11] 29470 } 29471 }, 29472 dpad: { 29473 up: gamepad.value.buttons[12], 29474 down: gamepad.value.buttons[13], 29475 left: gamepad.value.buttons[14], 29476 right: gamepad.value.buttons[15] 29477 }, 29478 back: gamepad.value.buttons[8], 29479 start: gamepad.value.buttons[9] 29480 }; 29481 } 29482 return null; 29483 }); 29484} 29485function useGamepad(options = {}) { 29486 const { 29487 navigator = defaultNavigator 29488 } = options; 29489 const isSupported = useSupported(() => navigator && "getGamepads" in navigator); 29490 const gamepads = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)([]); 29491 const onConnectedHook = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 29492 const onDisconnectedHook = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 29493 const stateFromGamepad = (gamepad) => { 29494 const hapticActuators = []; 29495 const vibrationActuator = "vibrationActuator" in gamepad ? gamepad.vibrationActuator : null; 29496 if (vibrationActuator) 29497 hapticActuators.push(vibrationActuator); 29498 if (gamepad.hapticActuators) 29499 hapticActuators.push(...gamepad.hapticActuators); 29500 return { 29501 id: gamepad.id, 29502 index: gamepad.index, 29503 connected: gamepad.connected, 29504 mapping: gamepad.mapping, 29505 timestamp: gamepad.timestamp, 29506 vibrationActuator: gamepad.vibrationActuator, 29507 hapticActuators, 29508 axes: gamepad.axes.map((axes) => axes), 29509 buttons: gamepad.buttons.map((button) => ({ pressed: button.pressed, touched: button.touched, value: button.value })) 29510 }; 29511 }; 29512 const updateGamepadState = () => { 29513 const _gamepads = (navigator == null ? undefined : navigator.getGamepads()) || []; 29514 for (const gamepad of _gamepads) { 29515 if (gamepad && gamepads.value[gamepad.index]) 29516 gamepads.value[gamepad.index] = stateFromGamepad(gamepad); 29517 } 29518 }; 29519 const { isActive, pause, resume } = useRafFn(updateGamepadState); 29520 const onGamepadConnected = (gamepad) => { 29521 if (!gamepads.value.some(({ index }) => index === gamepad.index)) { 29522 gamepads.value.push(stateFromGamepad(gamepad)); 29523 onConnectedHook.trigger(gamepad.index); 29524 } 29525 resume(); 29526 }; 29527 const onGamepadDisconnected = (gamepad) => { 29528 gamepads.value = gamepads.value.filter((x) => x.index !== gamepad.index); 29529 onDisconnectedHook.trigger(gamepad.index); 29530 }; 29531 const listenerOptions = { passive: true }; 29532 useEventListener("gamepadconnected", (e) => onGamepadConnected(e.gamepad), listenerOptions); 29533 useEventListener("gamepaddisconnected", (e) => onGamepadDisconnected(e.gamepad), listenerOptions); 29534 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => { 29535 const _gamepads = (navigator == null ? undefined : navigator.getGamepads()) || []; 29536 for (const gamepad of _gamepads) { 29537 if (gamepad && gamepads.value[gamepad.index]) 29538 onGamepadConnected(gamepad); 29539 } 29540 }); 29541 pause(); 29542 return { 29543 isSupported, 29544 onConnected: onConnectedHook.on, 29545 onDisconnected: onDisconnectedHook.on, 29546 gamepads, 29547 pause, 29548 resume, 29549 isActive 29550 }; 29551} 29552 29553function useGeolocation(options = {}) { 29554 const { 29555 enableHighAccuracy = true, 29556 maximumAge = 3e4, 29557 timeout = 27e3, 29558 navigator = defaultNavigator, 29559 immediate = true 29560 } = options; 29561 const isSupported = useSupported(() => navigator && "geolocation" in navigator); 29562 const locatedAt = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 29563 const error = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(null); 29564 const coords = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)({ 29565 accuracy: 0, 29566 latitude: Number.POSITIVE_INFINITY, 29567 longitude: Number.POSITIVE_INFINITY, 29568 altitude: null, 29569 altitudeAccuracy: null, 29570 heading: null, 29571 speed: null 29572 }); 29573 function updatePosition(position) { 29574 locatedAt.value = position.timestamp; 29575 coords.value = position.coords; 29576 error.value = null; 29577 } 29578 let watcher; 29579 function resume() { 29580 if (isSupported.value) { 29581 watcher = navigator.geolocation.watchPosition( 29582 updatePosition, 29583 (err) => error.value = err, 29584 { 29585 enableHighAccuracy, 29586 maximumAge, 29587 timeout 29588 } 29589 ); 29590 } 29591 } 29592 if (immediate) 29593 resume(); 29594 function pause() { 29595 if (watcher && navigator) 29596 navigator.geolocation.clearWatch(watcher); 29597 } 29598 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(() => { 29599 pause(); 29600 }); 29601 return { 29602 isSupported, 29603 coords, 29604 locatedAt, 29605 error, 29606 resume, 29607 pause 29608 }; 29609} 29610 29611const defaultEvents$1 = ["mousemove", "mousedown", "resize", "keydown", "touchstart", "wheel"]; 29612const oneMinute = 6e4; 29613function useIdle(timeout = oneMinute, options = {}) { 29614 const { 29615 initialState = false, 29616 listenForVisibilityChange = true, 29617 events = defaultEvents$1, 29618 window = defaultWindow, 29619 eventFilter = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.throttleFilter)(50) 29620 } = options; 29621 const idle = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialState); 29622 const lastActive = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)((0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.timestamp)()); 29623 let timer; 29624 const reset = () => { 29625 idle.value = false; 29626 clearTimeout(timer); 29627 timer = setTimeout(() => idle.value = true, timeout); 29628 }; 29629 const onEvent = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createFilterWrapper)( 29630 eventFilter, 29631 () => { 29632 lastActive.value = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.timestamp)(); 29633 reset(); 29634 } 29635 ); 29636 if (window) { 29637 const document = window.document; 29638 const listenerOptions = { passive: true }; 29639 for (const event of events) 29640 useEventListener(window, event, onEvent, listenerOptions); 29641 if (listenForVisibilityChange) { 29642 useEventListener(document, "visibilitychange", () => { 29643 if (!document.hidden) 29644 onEvent(); 29645 }, listenerOptions); 29646 } 29647 reset(); 29648 } 29649 return { 29650 idle, 29651 lastActive, 29652 reset 29653 }; 29654} 29655 29656async function loadImage(options) { 29657 return new Promise((resolve, reject) => { 29658 const img = new Image(); 29659 const { src, srcset, sizes, class: clazz, loading, crossorigin, referrerPolicy, width, height, decoding, fetchPriority, ismap, usemap } = options; 29660 img.src = src; 29661 if (srcset != null) 29662 img.srcset = srcset; 29663 if (sizes != null) 29664 img.sizes = sizes; 29665 if (clazz != null) 29666 img.className = clazz; 29667 if (loading != null) 29668 img.loading = loading; 29669 if (crossorigin != null) 29670 img.crossOrigin = crossorigin; 29671 if (referrerPolicy != null) 29672 img.referrerPolicy = referrerPolicy; 29673 if (width != null) 29674 img.width = width; 29675 if (height != null) 29676 img.height = height; 29677 if (decoding != null) 29678 img.decoding = decoding; 29679 if (fetchPriority != null) 29680 img.fetchPriority = fetchPriority; 29681 if (ismap != null) 29682 img.isMap = ismap; 29683 if (usemap != null) 29684 img.useMap = usemap; 29685 img.onload = () => resolve(img); 29686 img.onerror = reject; 29687 }); 29688} 29689function useImage(options, asyncStateOptions = {}) { 29690 const state = useAsyncState( 29691 () => loadImage((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options)), 29692 undefined, 29693 { 29694 resetOnExecute: true, 29695 ...asyncStateOptions 29696 } 29697 ); 29698 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 29699 () => (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options), 29700 () => state.execute(asyncStateOptions.delay), 29701 { deep: true } 29702 ); 29703 return state; 29704} 29705 29706function resolveElement(el) { 29707 if (typeof Window !== "undefined" && el instanceof Window) 29708 return el.document.documentElement; 29709 if (typeof Document !== "undefined" && el instanceof Document) 29710 return el.documentElement; 29711 return el; 29712} 29713 29714const ARRIVED_STATE_THRESHOLD_PIXELS = 1; 29715function useScroll(element, options = {}) { 29716 const { 29717 throttle = 0, 29718 idle = 200, 29719 onStop = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, 29720 onScroll = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, 29721 offset = { 29722 left: 0, 29723 right: 0, 29724 top: 0, 29725 bottom: 0 29726 }, 29727 eventListenerOptions = { 29728 capture: false, 29729 passive: true 29730 }, 29731 behavior = "auto", 29732 window = defaultWindow, 29733 onError = (e) => { 29734 console.error(e); 29735 } 29736 } = options; 29737 const internalX = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 29738 const internalY = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 29739 const x = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 29740 get() { 29741 return internalX.value; 29742 }, 29743 set(x2) { 29744 scrollTo(x2, undefined); 29745 } 29746 }); 29747 const y = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 29748 get() { 29749 return internalY.value; 29750 }, 29751 set(y2) { 29752 scrollTo(undefined, y2); 29753 } 29754 }); 29755 function scrollTo(_x, _y) { 29756 var _a, _b, _c, _d; 29757 if (!window) 29758 return; 29759 const _element = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(element); 29760 if (!_element) 29761 return; 29762 (_c = _element instanceof Document ? window.document.body : _element) == null ? undefined : _c.scrollTo({ 29763 top: (_a = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(_y)) != null ? _a : y.value, 29764 left: (_b = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(_x)) != null ? _b : x.value, 29765 behavior: (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(behavior) 29766 }); 29767 const scrollContainer = ((_d = _element == null ? undefined : _element.document) == null ? undefined : _d.documentElement) || (_element == null ? undefined : _element.documentElement) || _element; 29768 if (x != null) 29769 internalX.value = scrollContainer.scrollLeft; 29770 if (y != null) 29771 internalY.value = scrollContainer.scrollTop; 29772 } 29773 const isScrolling = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 29774 const arrivedState = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)({ 29775 left: true, 29776 right: false, 29777 top: true, 29778 bottom: false 29779 }); 29780 const directions = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)({ 29781 left: false, 29782 right: false, 29783 top: false, 29784 bottom: false 29785 }); 29786 const onScrollEnd = (e) => { 29787 if (!isScrolling.value) 29788 return; 29789 isScrolling.value = false; 29790 directions.left = false; 29791 directions.right = false; 29792 directions.top = false; 29793 directions.bottom = false; 29794 onStop(e); 29795 }; 29796 const onScrollEndDebounced = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useDebounceFn)(onScrollEnd, throttle + idle); 29797 const setArrivedState = (target) => { 29798 var _a; 29799 if (!window) 29800 return; 29801 const el = ((_a = target == null ? undefined : target.document) == null ? undefined : _a.documentElement) || (target == null ? undefined : target.documentElement) || unrefElement(target); 29802 const { display, flexDirection, direction } = getComputedStyle(el); 29803 const directionMultipler = direction === "rtl" ? -1 : 1; 29804 const scrollLeft = el.scrollLeft; 29805 directions.left = scrollLeft < internalX.value; 29806 directions.right = scrollLeft > internalX.value; 29807 const left = scrollLeft * directionMultipler <= (offset.left || 0); 29808 const right = scrollLeft * directionMultipler + el.clientWidth >= el.scrollWidth - (offset.right || 0) - ARRIVED_STATE_THRESHOLD_PIXELS; 29809 if (display === "flex" && flexDirection === "row-reverse") { 29810 arrivedState.left = right; 29811 arrivedState.right = left; 29812 } else { 29813 arrivedState.left = left; 29814 arrivedState.right = right; 29815 } 29816 internalX.value = scrollLeft; 29817 let scrollTop = el.scrollTop; 29818 if (target === window.document && !scrollTop) 29819 scrollTop = window.document.body.scrollTop; 29820 directions.top = scrollTop < internalY.value; 29821 directions.bottom = scrollTop > internalY.value; 29822 const top = scrollTop <= (offset.top || 0); 29823 const bottom = scrollTop + el.clientHeight >= el.scrollHeight - (offset.bottom || 0) - ARRIVED_STATE_THRESHOLD_PIXELS; 29824 if (display === "flex" && flexDirection === "column-reverse") { 29825 arrivedState.top = bottom; 29826 arrivedState.bottom = top; 29827 } else { 29828 arrivedState.top = top; 29829 arrivedState.bottom = bottom; 29830 } 29831 internalY.value = scrollTop; 29832 }; 29833 const onScrollHandler = (e) => { 29834 var _a; 29835 if (!window) 29836 return; 29837 const eventTarget = (_a = e.target.documentElement) != null ? _a : e.target; 29838 setArrivedState(eventTarget); 29839 isScrolling.value = true; 29840 onScrollEndDebounced(e); 29841 onScroll(e); 29842 }; 29843 useEventListener( 29844 element, 29845 "scroll", 29846 throttle ? (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useThrottleFn)(onScrollHandler, throttle, true, false) : onScrollHandler, 29847 eventListenerOptions 29848 ); 29849 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => { 29850 try { 29851 const _element = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(element); 29852 if (!_element) 29853 return; 29854 setArrivedState(_element); 29855 } catch (e) { 29856 onError(e); 29857 } 29858 }); 29859 useEventListener( 29860 element, 29861 "scrollend", 29862 onScrollEnd, 29863 eventListenerOptions 29864 ); 29865 return { 29866 x, 29867 y, 29868 isScrolling, 29869 arrivedState, 29870 directions, 29871 measure() { 29872 const _element = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(element); 29873 if (window && _element) 29874 setArrivedState(_element); 29875 } 29876 }; 29877} 29878 29879function useInfiniteScroll(element, onLoadMore, options = {}) { 29880 var _a; 29881 const { 29882 direction = "bottom", 29883 interval = 100, 29884 canLoadMore = () => true 29885 } = options; 29886 const state = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)(useScroll( 29887 element, 29888 { 29889 ...options, 29890 offset: { 29891 [direction]: (_a = options.distance) != null ? _a : 0, 29892 ...options.offset 29893 } 29894 } 29895 )); 29896 const promise = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 29897 const isLoading = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => !!promise.value); 29898 const observedElement = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 29899 return resolveElement((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(element)); 29900 }); 29901 const isElementVisible = useElementVisibility(observedElement); 29902 function checkAndLoad() { 29903 state.measure(); 29904 if (!observedElement.value || !isElementVisible.value || !canLoadMore(observedElement.value)) 29905 return; 29906 const { scrollHeight, clientHeight, scrollWidth, clientWidth } = observedElement.value; 29907 const isNarrower = direction === "bottom" || direction === "top" ? scrollHeight <= clientHeight : scrollWidth <= clientWidth; 29908 if (state.arrivedState[direction] || isNarrower) { 29909 if (!promise.value) { 29910 promise.value = Promise.all([ 29911 onLoadMore(state), 29912 new Promise((resolve) => setTimeout(resolve, interval)) 29913 ]).finally(() => { 29914 promise.value = null; 29915 (0,vue__WEBPACK_IMPORTED_MODULE_1__.nextTick)(() => checkAndLoad()); 29916 }); 29917 } 29918 } 29919 } 29920 const stop = (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 29921 () => [state.arrivedState[direction], isElementVisible.value], 29922 checkAndLoad, 29923 { immediate: true } 29924 ); 29925 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnUnmounted)(stop); 29926 return { 29927 isLoading, 29928 reset() { 29929 (0,vue__WEBPACK_IMPORTED_MODULE_1__.nextTick)(() => checkAndLoad()); 29930 } 29931 }; 29932} 29933 29934const defaultEvents = ["mousedown", "mouseup", "keydown", "keyup"]; 29935function useKeyModifier(modifier, options = {}) { 29936 const { 29937 events = defaultEvents, 29938 document = defaultDocument, 29939 initial = null 29940 } = options; 29941 const state = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initial); 29942 if (document) { 29943 events.forEach((listenerEvent) => { 29944 useEventListener(document, listenerEvent, (evt) => { 29945 if (typeof evt.getModifierState === "function") 29946 state.value = evt.getModifierState(modifier); 29947 }, { passive: true }); 29948 }); 29949 } 29950 return state; 29951} 29952 29953function useLocalStorage(key, initialValue, options = {}) { 29954 const { window = defaultWindow } = options; 29955 return useStorage(key, initialValue, window == null ? undefined : window.localStorage, options); 29956} 29957 29958const DefaultMagicKeysAliasMap = { 29959 ctrl: "control", 29960 command: "meta", 29961 cmd: "meta", 29962 option: "alt", 29963 up: "arrowup", 29964 down: "arrowdown", 29965 left: "arrowleft", 29966 right: "arrowright" 29967}; 29968 29969function useMagicKeys(options = {}) { 29970 const { 29971 reactive: useReactive = false, 29972 target = defaultWindow, 29973 aliasMap = DefaultMagicKeysAliasMap, 29974 passive = true, 29975 onEventFired = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop 29976 } = options; 29977 const current = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)(/* @__PURE__ */ new Set()); 29978 const obj = { 29979 toJSON() { 29980 return {}; 29981 }, 29982 current 29983 }; 29984 const refs = useReactive ? (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)(obj) : obj; 29985 const metaDeps = /* @__PURE__ */ new Set(); 29986 const usedKeys = /* @__PURE__ */ new Set(); 29987 function setRefs(key, value) { 29988 if (key in refs) { 29989 if (useReactive) 29990 refs[key] = value; 29991 else 29992 refs[key].value = value; 29993 } 29994 } 29995 function reset() { 29996 current.clear(); 29997 for (const key of usedKeys) 29998 setRefs(key, false); 29999 } 30000 function updateRefs(e, value) { 30001 var _a, _b; 30002 const key = (_a = e.key) == null ? undefined : _a.toLowerCase(); 30003 const code = (_b = e.code) == null ? undefined : _b.toLowerCase(); 30004 const values = [code, key].filter(Boolean); 30005 if (key) { 30006 if (value) 30007 current.add(key); 30008 else 30009 current.delete(key); 30010 } 30011 for (const key2 of values) { 30012 usedKeys.add(key2); 30013 setRefs(key2, value); 30014 } 30015 if (key === "meta" && !value) { 30016 metaDeps.forEach((key2) => { 30017 current.delete(key2); 30018 setRefs(key2, false); 30019 }); 30020 metaDeps.clear(); 30021 } else if (typeof e.getModifierState === "function" && e.getModifierState("Meta") && value) { 30022 [...current, ...values].forEach((key2) => metaDeps.add(key2)); 30023 } 30024 } 30025 useEventListener(target, "keydown", (e) => { 30026 updateRefs(e, true); 30027 return onEventFired(e); 30028 }, { passive }); 30029 useEventListener(target, "keyup", (e) => { 30030 updateRefs(e, false); 30031 return onEventFired(e); 30032 }, { passive }); 30033 useEventListener("blur", reset, { passive }); 30034 useEventListener("focus", reset, { passive }); 30035 const proxy = new Proxy( 30036 refs, 30037 { 30038 get(target2, prop, rec) { 30039 if (typeof prop !== "string") 30040 return Reflect.get(target2, prop, rec); 30041 prop = prop.toLowerCase(); 30042 if (prop in aliasMap) 30043 prop = aliasMap[prop]; 30044 if (!(prop in refs)) { 30045 if (/[+_-]/.test(prop)) { 30046 const keys = prop.split(/[+_-]/g).map((i) => i.trim()); 30047 refs[prop] = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => keys.map((key) => (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(proxy[key])).every(Boolean)); 30048 } else { 30049 refs[prop] = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30050 } 30051 } 30052 const r = Reflect.get(target2, prop, rec); 30053 return useReactive ? (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(r) : r; 30054 } 30055 } 30056 ); 30057 return proxy; 30058} 30059 30060function usingElRef(source, cb) { 30061 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(source)) 30062 cb((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(source)); 30063} 30064function timeRangeToArray(timeRanges) { 30065 let ranges = []; 30066 for (let i = 0; i < timeRanges.length; ++i) 30067 ranges = [...ranges, [timeRanges.start(i), timeRanges.end(i)]]; 30068 return ranges; 30069} 30070function tracksToArray(tracks) { 30071 return Array.from(tracks).map(({ label, kind, language, mode, activeCues, cues, inBandMetadataTrackDispatchType }, id) => ({ id, label, kind, language, mode, activeCues, cues, inBandMetadataTrackDispatchType })); 30072} 30073const defaultOptions = { 30074 src: "", 30075 tracks: [] 30076}; 30077function useMediaControls(target, options = {}) { 30078 target = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(target); 30079 options = { 30080 ...defaultOptions, 30081 ...options 30082 }; 30083 const { 30084 document = defaultDocument 30085 } = options; 30086 const listenerOptions = { passive: true }; 30087 const currentTime = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 30088 const duration = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 30089 const seeking = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30090 const volume = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(1); 30091 const waiting = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30092 const ended = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30093 const playing = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30094 const rate = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(1); 30095 const stalled = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30096 const buffered = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)([]); 30097 const tracks = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)([]); 30098 const selectedTrack = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(-1); 30099 const isPictureInPicture = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30100 const muted = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30101 const supportsPictureInPicture = document && "pictureInPictureEnabled" in document; 30102 const sourceErrorEvent = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 30103 const playbackErrorEvent = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 30104 const disableTrack = (track) => { 30105 usingElRef(target, (el) => { 30106 if (track) { 30107 const id = typeof track === "number" ? track : track.id; 30108 el.textTracks[id].mode = "disabled"; 30109 } else { 30110 for (let i = 0; i < el.textTracks.length; ++i) 30111 el.textTracks[i].mode = "disabled"; 30112 } 30113 selectedTrack.value = -1; 30114 }); 30115 }; 30116 const enableTrack = (track, disableTracks = true) => { 30117 usingElRef(target, (el) => { 30118 const id = typeof track === "number" ? track : track.id; 30119 if (disableTracks) 30120 disableTrack(); 30121 el.textTracks[id].mode = "showing"; 30122 selectedTrack.value = id; 30123 }); 30124 }; 30125 const togglePictureInPicture = () => { 30126 return new Promise((resolve, reject) => { 30127 usingElRef(target, async (el) => { 30128 if (supportsPictureInPicture) { 30129 if (!isPictureInPicture.value) { 30130 el.requestPictureInPicture().then(resolve).catch(reject); 30131 } else { 30132 document.exitPictureInPicture().then(resolve).catch(reject); 30133 } 30134 } 30135 }); 30136 }); 30137 }; 30138 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watchEffect)(() => { 30139 if (!document) 30140 return; 30141 const el = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 30142 if (!el) 30143 return; 30144 const src = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.src); 30145 let sources = []; 30146 if (!src) 30147 return; 30148 if (typeof src === "string") 30149 sources = [{ src }]; 30150 else if (Array.isArray(src)) 30151 sources = src; 30152 else if ((0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(src)) 30153 sources = [src]; 30154 el.querySelectorAll("source").forEach((e) => { 30155 e.remove(); 30156 }); 30157 sources.forEach(({ src: src2, type, media }) => { 30158 const source = document.createElement("source"); 30159 source.setAttribute("src", src2); 30160 source.setAttribute("type", type || ""); 30161 source.setAttribute("media", media || ""); 30162 useEventListener(source, "error", sourceErrorEvent.trigger, listenerOptions); 30163 el.appendChild(source); 30164 }); 30165 el.load(); 30166 }); 30167 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)([target, volume], () => { 30168 const el = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 30169 if (!el) 30170 return; 30171 el.volume = volume.value; 30172 }); 30173 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)([target, muted], () => { 30174 const el = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 30175 if (!el) 30176 return; 30177 el.muted = muted.value; 30178 }); 30179 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)([target, rate], () => { 30180 const el = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 30181 if (!el) 30182 return; 30183 el.playbackRate = rate.value; 30184 }); 30185 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watchEffect)(() => { 30186 if (!document) 30187 return; 30188 const textTracks = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.tracks); 30189 const el = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 30190 if (!textTracks || !textTracks.length || !el) 30191 return; 30192 el.querySelectorAll("track").forEach((e) => e.remove()); 30193 textTracks.forEach(({ default: isDefault, kind, label, src, srcLang }, i) => { 30194 const track = document.createElement("track"); 30195 track.default = isDefault || false; 30196 track.kind = kind; 30197 track.label = label; 30198 track.src = src; 30199 track.srclang = srcLang; 30200 if (track.default) 30201 selectedTrack.value = i; 30202 el.appendChild(track); 30203 }); 30204 }); 30205 const { ignoreUpdates: ignoreCurrentTimeUpdates } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchIgnorable)(currentTime, (time) => { 30206 const el = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 30207 if (!el) 30208 return; 30209 el.currentTime = time; 30210 }); 30211 const { ignoreUpdates: ignorePlayingUpdates } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchIgnorable)(playing, (isPlaying) => { 30212 const el = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 30213 if (!el) 30214 return; 30215 if (isPlaying) { 30216 el.play().catch((e) => { 30217 playbackErrorEvent.trigger(e); 30218 throw e; 30219 }); 30220 } else { 30221 el.pause(); 30222 } 30223 }); 30224 useEventListener( 30225 target, 30226 "timeupdate", 30227 () => ignoreCurrentTimeUpdates(() => currentTime.value = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target).currentTime), 30228 listenerOptions 30229 ); 30230 useEventListener( 30231 target, 30232 "durationchange", 30233 () => duration.value = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target).duration, 30234 listenerOptions 30235 ); 30236 useEventListener( 30237 target, 30238 "progress", 30239 () => buffered.value = timeRangeToArray((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target).buffered), 30240 listenerOptions 30241 ); 30242 useEventListener( 30243 target, 30244 "seeking", 30245 () => seeking.value = true, 30246 listenerOptions 30247 ); 30248 useEventListener( 30249 target, 30250 "seeked", 30251 () => seeking.value = false, 30252 listenerOptions 30253 ); 30254 useEventListener( 30255 target, 30256 ["waiting", "loadstart"], 30257 () => { 30258 waiting.value = true; 30259 ignorePlayingUpdates(() => playing.value = false); 30260 }, 30261 listenerOptions 30262 ); 30263 useEventListener( 30264 target, 30265 "loadeddata", 30266 () => waiting.value = false, 30267 listenerOptions 30268 ); 30269 useEventListener( 30270 target, 30271 "playing", 30272 () => { 30273 waiting.value = false; 30274 ended.value = false; 30275 ignorePlayingUpdates(() => playing.value = true); 30276 }, 30277 listenerOptions 30278 ); 30279 useEventListener( 30280 target, 30281 "ratechange", 30282 () => rate.value = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target).playbackRate, 30283 listenerOptions 30284 ); 30285 useEventListener( 30286 target, 30287 "stalled", 30288 () => stalled.value = true, 30289 listenerOptions 30290 ); 30291 useEventListener( 30292 target, 30293 "ended", 30294 () => ended.value = true, 30295 listenerOptions 30296 ); 30297 useEventListener( 30298 target, 30299 "pause", 30300 () => ignorePlayingUpdates(() => playing.value = false), 30301 listenerOptions 30302 ); 30303 useEventListener( 30304 target, 30305 "play", 30306 () => ignorePlayingUpdates(() => playing.value = true), 30307 listenerOptions 30308 ); 30309 useEventListener( 30310 target, 30311 "enterpictureinpicture", 30312 () => isPictureInPicture.value = true, 30313 listenerOptions 30314 ); 30315 useEventListener( 30316 target, 30317 "leavepictureinpicture", 30318 () => isPictureInPicture.value = false, 30319 listenerOptions 30320 ); 30321 useEventListener( 30322 target, 30323 "volumechange", 30324 () => { 30325 const el = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 30326 if (!el) 30327 return; 30328 volume.value = el.volume; 30329 muted.value = el.muted; 30330 }, 30331 listenerOptions 30332 ); 30333 const listeners = []; 30334 const stop = (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)([target], () => { 30335 const el = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(target); 30336 if (!el) 30337 return; 30338 stop(); 30339 listeners[0] = useEventListener(el.textTracks, "addtrack", () => tracks.value = tracksToArray(el.textTracks), listenerOptions); 30340 listeners[1] = useEventListener(el.textTracks, "removetrack", () => tracks.value = tracksToArray(el.textTracks), listenerOptions); 30341 listeners[2] = useEventListener(el.textTracks, "change", () => tracks.value = tracksToArray(el.textTracks), listenerOptions); 30342 }); 30343 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(() => listeners.forEach((listener) => listener())); 30344 return { 30345 currentTime, 30346 duration, 30347 waiting, 30348 seeking, 30349 ended, 30350 stalled, 30351 buffered, 30352 playing, 30353 rate, 30354 // Volume 30355 volume, 30356 muted, 30357 // Tracks 30358 tracks, 30359 selectedTrack, 30360 enableTrack, 30361 disableTrack, 30362 // Picture in Picture 30363 supportsPictureInPicture, 30364 togglePictureInPicture, 30365 isPictureInPicture, 30366 // Events 30367 onSourceError: sourceErrorEvent.on, 30368 onPlaybackError: playbackErrorEvent.on 30369 }; 30370} 30371 30372function useMemoize(resolver, options) { 30373 const initCache = () => { 30374 if (options == null ? undefined : options.cache) 30375 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowReactive)(options.cache); 30376 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowReactive)(/* @__PURE__ */ new Map()); 30377 }; 30378 const cache = initCache(); 30379 const generateKey = (...args) => (options == null ? undefined : options.getKey) ? options.getKey(...args) : JSON.stringify(args); 30380 const _loadData = (key, ...args) => { 30381 cache.set(key, resolver(...args)); 30382 return cache.get(key); 30383 }; 30384 const loadData = (...args) => _loadData(generateKey(...args), ...args); 30385 const deleteData = (...args) => { 30386 cache.delete(generateKey(...args)); 30387 }; 30388 const clearData = () => { 30389 cache.clear(); 30390 }; 30391 const memoized = (...args) => { 30392 const key = generateKey(...args); 30393 if (cache.has(key)) 30394 return cache.get(key); 30395 return _loadData(key, ...args); 30396 }; 30397 memoized.load = loadData; 30398 memoized.delete = deleteData; 30399 memoized.clear = clearData; 30400 memoized.generateKey = generateKey; 30401 memoized.cache = cache; 30402 return memoized; 30403} 30404 30405function useMemory(options = {}) { 30406 const memory = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 30407 const isSupported = useSupported(() => typeof performance !== "undefined" && "memory" in performance); 30408 if (isSupported.value) { 30409 const { interval = 1e3 } = options; 30410 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useIntervalFn)(() => { 30411 memory.value = performance.memory; 30412 }, interval, { immediate: options.immediate, immediateCallback: options.immediateCallback }); 30413 } 30414 return { isSupported, memory }; 30415} 30416 30417const UseMouseBuiltinExtractors = { 30418 page: (event) => [event.pageX, event.pageY], 30419 client: (event) => [event.clientX, event.clientY], 30420 screen: (event) => [event.screenX, event.screenY], 30421 movement: (event) => event instanceof Touch ? null : [event.movementX, event.movementY] 30422}; 30423function useMouse(options = {}) { 30424 const { 30425 type = "page", 30426 touch = true, 30427 resetOnTouchEnds = false, 30428 initialValue = { x: 0, y: 0 }, 30429 window = defaultWindow, 30430 target = window, 30431 scroll = true, 30432 eventFilter 30433 } = options; 30434 let _prevMouseEvent = null; 30435 let _prevScrollX = 0; 30436 let _prevScrollY = 0; 30437 const x = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialValue.x); 30438 const y = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialValue.y); 30439 const sourceType = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 30440 const extractor = typeof type === "function" ? type : UseMouseBuiltinExtractors[type]; 30441 const mouseHandler = (event) => { 30442 const result = extractor(event); 30443 _prevMouseEvent = event; 30444 if (result) { 30445 [x.value, y.value] = result; 30446 sourceType.value = "mouse"; 30447 } 30448 if (window) { 30449 _prevScrollX = window.scrollX; 30450 _prevScrollY = window.scrollY; 30451 } 30452 }; 30453 const touchHandler = (event) => { 30454 if (event.touches.length > 0) { 30455 const result = extractor(event.touches[0]); 30456 if (result) { 30457 [x.value, y.value] = result; 30458 sourceType.value = "touch"; 30459 } 30460 } 30461 }; 30462 const scrollHandler = () => { 30463 if (!_prevMouseEvent || !window) 30464 return; 30465 const pos = extractor(_prevMouseEvent); 30466 if (_prevMouseEvent instanceof MouseEvent && pos) { 30467 x.value = pos[0] + window.scrollX - _prevScrollX; 30468 y.value = pos[1] + window.scrollY - _prevScrollY; 30469 } 30470 }; 30471 const reset = () => { 30472 x.value = initialValue.x; 30473 y.value = initialValue.y; 30474 }; 30475 const mouseHandlerWrapper = eventFilter ? (event) => eventFilter(() => mouseHandler(event), {}) : (event) => mouseHandler(event); 30476 const touchHandlerWrapper = eventFilter ? (event) => eventFilter(() => touchHandler(event), {}) : (event) => touchHandler(event); 30477 const scrollHandlerWrapper = eventFilter ? () => eventFilter(() => scrollHandler(), {}) : () => scrollHandler(); 30478 if (target) { 30479 const listenerOptions = { passive: true }; 30480 useEventListener(target, ["mousemove", "dragover"], mouseHandlerWrapper, listenerOptions); 30481 if (touch && type !== "movement") { 30482 useEventListener(target, ["touchstart", "touchmove"], touchHandlerWrapper, listenerOptions); 30483 if (resetOnTouchEnds) 30484 useEventListener(target, "touchend", reset, listenerOptions); 30485 } 30486 if (scroll && type === "page") 30487 useEventListener(window, "scroll", scrollHandlerWrapper, listenerOptions); 30488 } 30489 return { 30490 x, 30491 y, 30492 sourceType 30493 }; 30494} 30495 30496function useMouseInElement(target, options = {}) { 30497 const { 30498 handleOutside = true, 30499 window = defaultWindow 30500 } = options; 30501 const type = options.type || "page"; 30502 const { x, y, sourceType } = useMouse(options); 30503 const targetRef = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(target != null ? target : window == null ? undefined : window.document.body); 30504 const elementX = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 30505 const elementY = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 30506 const elementPositionX = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 30507 const elementPositionY = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 30508 const elementHeight = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 30509 const elementWidth = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 30510 const isOutside = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(true); 30511 let stop = () => { 30512 }; 30513 if (window) { 30514 stop = (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 30515 [targetRef, x, y], 30516 () => { 30517 const el = unrefElement(targetRef); 30518 if (!el || !(el instanceof Element)) 30519 return; 30520 const { 30521 left, 30522 top, 30523 width, 30524 height 30525 } = el.getBoundingClientRect(); 30526 elementPositionX.value = left + (type === "page" ? window.pageXOffset : 0); 30527 elementPositionY.value = top + (type === "page" ? window.pageYOffset : 0); 30528 elementHeight.value = height; 30529 elementWidth.value = width; 30530 const elX = x.value - elementPositionX.value; 30531 const elY = y.value - elementPositionY.value; 30532 isOutside.value = width === 0 || height === 0 || elX < 0 || elY < 0 || elX > width || elY > height; 30533 if (handleOutside || !isOutside.value) { 30534 elementX.value = elX; 30535 elementY.value = elY; 30536 } 30537 }, 30538 { immediate: true } 30539 ); 30540 useEventListener( 30541 document, 30542 "mouseleave", 30543 () => isOutside.value = true, 30544 { passive: true } 30545 ); 30546 } 30547 return { 30548 x, 30549 y, 30550 sourceType, 30551 elementX, 30552 elementY, 30553 elementPositionX, 30554 elementPositionY, 30555 elementHeight, 30556 elementWidth, 30557 isOutside, 30558 stop 30559 }; 30560} 30561 30562function useMousePressed(options = {}) { 30563 const { 30564 touch = true, 30565 drag = true, 30566 capture = false, 30567 initialValue = false, 30568 window = defaultWindow 30569 } = options; 30570 const pressed = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialValue); 30571 const sourceType = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 30572 if (!window) { 30573 return { 30574 pressed, 30575 sourceType 30576 }; 30577 } 30578 const onPressed = (srcType) => (event) => { 30579 var _a; 30580 pressed.value = true; 30581 sourceType.value = srcType; 30582 (_a = options.onPressed) == null ? undefined : _a.call(options, event); 30583 }; 30584 const onReleased = (event) => { 30585 var _a; 30586 pressed.value = false; 30587 sourceType.value = null; 30588 (_a = options.onReleased) == null ? undefined : _a.call(options, event); 30589 }; 30590 const target = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => unrefElement(options.target) || window); 30591 const listenerOptions = { passive: true, capture }; 30592 useEventListener(target, "mousedown", onPressed("mouse"), listenerOptions); 30593 useEventListener(window, "mouseleave", onReleased, listenerOptions); 30594 useEventListener(window, "mouseup", onReleased, listenerOptions); 30595 if (drag) { 30596 useEventListener(target, "dragstart", onPressed("mouse"), listenerOptions); 30597 useEventListener(window, "drop", onReleased, listenerOptions); 30598 useEventListener(window, "dragend", onReleased, listenerOptions); 30599 } 30600 if (touch) { 30601 useEventListener(target, "touchstart", onPressed("touch"), listenerOptions); 30602 useEventListener(window, "touchend", onReleased, listenerOptions); 30603 useEventListener(window, "touchcancel", onReleased, listenerOptions); 30604 } 30605 return { 30606 pressed, 30607 sourceType 30608 }; 30609} 30610 30611function useNavigatorLanguage(options = {}) { 30612 const { window = defaultWindow } = options; 30613 const navigator = window == null ? undefined : window.navigator; 30614 const isSupported = useSupported(() => navigator && "language" in navigator); 30615 const language = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(navigator == null ? undefined : navigator.language); 30616 useEventListener(window, "languagechange", () => { 30617 if (navigator) 30618 language.value = navigator.language; 30619 }, { passive: true }); 30620 return { 30621 isSupported, 30622 language 30623 }; 30624} 30625 30626function useNetwork(options = {}) { 30627 const { window = defaultWindow } = options; 30628 const navigator = window == null ? undefined : window.navigator; 30629 const isSupported = useSupported(() => navigator && "connection" in navigator); 30630 const isOnline = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(true); 30631 const saveData = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30632 const offlineAt = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(undefined); 30633 const onlineAt = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(undefined); 30634 const downlink = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(undefined); 30635 const downlinkMax = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(undefined); 30636 const rtt = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(undefined); 30637 const effectiveType = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(undefined); 30638 const type = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)("unknown"); 30639 const connection = isSupported.value && navigator.connection; 30640 function updateNetworkInformation() { 30641 if (!navigator) 30642 return; 30643 isOnline.value = navigator.onLine; 30644 offlineAt.value = isOnline.value ? undefined : Date.now(); 30645 onlineAt.value = isOnline.value ? Date.now() : undefined; 30646 if (connection) { 30647 downlink.value = connection.downlink; 30648 downlinkMax.value = connection.downlinkMax; 30649 effectiveType.value = connection.effectiveType; 30650 rtt.value = connection.rtt; 30651 saveData.value = connection.saveData; 30652 type.value = connection.type; 30653 } 30654 } 30655 const listenerOptions = { passive: true }; 30656 if (window) { 30657 useEventListener(window, "offline", () => { 30658 isOnline.value = false; 30659 offlineAt.value = Date.now(); 30660 }, listenerOptions); 30661 useEventListener(window, "online", () => { 30662 isOnline.value = true; 30663 onlineAt.value = Date.now(); 30664 }, listenerOptions); 30665 } 30666 if (connection) 30667 useEventListener(connection, "change", updateNetworkInformation, listenerOptions); 30668 updateNetworkInformation(); 30669 return { 30670 isSupported, 30671 isOnline: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(isOnline), 30672 saveData: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(saveData), 30673 offlineAt: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(offlineAt), 30674 onlineAt: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(onlineAt), 30675 downlink: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(downlink), 30676 downlinkMax: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(downlinkMax), 30677 effectiveType: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(effectiveType), 30678 rtt: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(rtt), 30679 type: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(type) 30680 }; 30681} 30682 30683function useNow(options = {}) { 30684 const { 30685 controls: exposeControls = false, 30686 interval = "requestAnimationFrame" 30687 } = options; 30688 const now = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(/* @__PURE__ */ new Date()); 30689 const update = () => now.value = /* @__PURE__ */ new Date(); 30690 const controls = interval === "requestAnimationFrame" ? useRafFn(update, { immediate: true }) : (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useIntervalFn)(update, interval, { immediate: true }); 30691 if (exposeControls) { 30692 return { 30693 now, 30694 ...controls 30695 }; 30696 } else { 30697 return now; 30698 } 30699} 30700 30701function useObjectUrl(object) { 30702 const url = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 30703 const release = () => { 30704 if (url.value) 30705 URL.revokeObjectURL(url.value); 30706 url.value = undefined; 30707 }; 30708 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 30709 () => (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(object), 30710 (newObject) => { 30711 release(); 30712 if (newObject) 30713 url.value = URL.createObjectURL(newObject); 30714 }, 30715 { immediate: true } 30716 ); 30717 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(release); 30718 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(url); 30719} 30720 30721function useClamp(value, min, max) { 30722 if (typeof value === "function" || (0,vue__WEBPACK_IMPORTED_MODULE_1__.isReadonly)(value)) 30723 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.clamp)((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(value), (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(min), (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(max))); 30724 const _value = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(value); 30725 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 30726 get() { 30727 return _value.value = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.clamp)(_value.value, (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(min), (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(max)); 30728 }, 30729 set(value2) { 30730 _value.value = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.clamp)(value2, (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(min), (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(max)); 30731 } 30732 }); 30733} 30734 30735function useOffsetPagination(options) { 30736 const { 30737 total = Number.POSITIVE_INFINITY, 30738 pageSize = 10, 30739 page = 1, 30740 onPageChange = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, 30741 onPageSizeChange = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, 30742 onPageCountChange = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop 30743 } = options; 30744 const currentPageSize = useClamp(pageSize, 1, Number.POSITIVE_INFINITY); 30745 const pageCount = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => Math.max( 30746 1, 30747 Math.ceil((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(total) / (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(currentPageSize)) 30748 )); 30749 const currentPage = useClamp(page, 1, pageCount); 30750 const isFirstPage = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => currentPage.value === 1); 30751 const isLastPage = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => currentPage.value === pageCount.value); 30752 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.isRef)(page)) { 30753 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.syncRef)(page, currentPage, { 30754 direction: (0,vue__WEBPACK_IMPORTED_MODULE_1__.isReadonly)(page) ? "ltr" : "both" 30755 }); 30756 } 30757 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.isRef)(pageSize)) { 30758 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.syncRef)(pageSize, currentPageSize, { 30759 direction: (0,vue__WEBPACK_IMPORTED_MODULE_1__.isReadonly)(pageSize) ? "ltr" : "both" 30760 }); 30761 } 30762 function prev() { 30763 currentPage.value--; 30764 } 30765 function next() { 30766 currentPage.value++; 30767 } 30768 const returnValue = { 30769 currentPage, 30770 currentPageSize, 30771 pageCount, 30772 isFirstPage, 30773 isLastPage, 30774 prev, 30775 next 30776 }; 30777 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(currentPage, () => { 30778 onPageChange((0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)(returnValue)); 30779 }); 30780 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(currentPageSize, () => { 30781 onPageSizeChange((0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)(returnValue)); 30782 }); 30783 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(pageCount, () => { 30784 onPageCountChange((0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)(returnValue)); 30785 }); 30786 return returnValue; 30787} 30788 30789function useOnline(options = {}) { 30790 const { isOnline } = useNetwork(options); 30791 return isOnline; 30792} 30793 30794function usePageLeave(options = {}) { 30795 const { window = defaultWindow } = options; 30796 const isLeft = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30797 const handler = (event) => { 30798 if (!window) 30799 return; 30800 event = event || window.event; 30801 const from = event.relatedTarget || event.toElement; 30802 isLeft.value = !from; 30803 }; 30804 if (window) { 30805 const listenerOptions = { passive: true }; 30806 useEventListener(window, "mouseout", handler, listenerOptions); 30807 useEventListener(window.document, "mouseleave", handler, listenerOptions); 30808 useEventListener(window.document, "mouseenter", handler, listenerOptions); 30809 } 30810 return isLeft; 30811} 30812 30813function useScreenOrientation(options = {}) { 30814 const { 30815 window = defaultWindow 30816 } = options; 30817 const isSupported = useSupported(() => window && "screen" in window && "orientation" in window.screen); 30818 const screenOrientation = isSupported.value ? window.screen.orientation : {}; 30819 const orientation = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(screenOrientation.type); 30820 const angle = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(screenOrientation.angle || 0); 30821 if (isSupported.value) { 30822 useEventListener(window, "orientationchange", () => { 30823 orientation.value = screenOrientation.type; 30824 angle.value = screenOrientation.angle; 30825 }, { passive: true }); 30826 } 30827 const lockOrientation = (type) => { 30828 if (isSupported.value && typeof screenOrientation.lock === "function") 30829 return screenOrientation.lock(type); 30830 return Promise.reject(new Error("Not supported")); 30831 }; 30832 const unlockOrientation = () => { 30833 if (isSupported.value && typeof screenOrientation.unlock === "function") 30834 screenOrientation.unlock(); 30835 }; 30836 return { 30837 isSupported, 30838 orientation, 30839 angle, 30840 lockOrientation, 30841 unlockOrientation 30842 }; 30843} 30844 30845function useParallax(target, options = {}) { 30846 const { 30847 deviceOrientationTiltAdjust = (i) => i, 30848 deviceOrientationRollAdjust = (i) => i, 30849 mouseTiltAdjust = (i) => i, 30850 mouseRollAdjust = (i) => i, 30851 window = defaultWindow 30852 } = options; 30853 const orientation = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)(useDeviceOrientation({ window })); 30854 const screenOrientation = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)(useScreenOrientation({ window })); 30855 const { 30856 elementX: x, 30857 elementY: y, 30858 elementWidth: width, 30859 elementHeight: height 30860 } = useMouseInElement(target, { handleOutside: false, window }); 30861 const source = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 30862 if (orientation.isSupported && (orientation.alpha != null && orientation.alpha !== 0 || orientation.gamma != null && orientation.gamma !== 0)) { 30863 return "deviceOrientation"; 30864 } 30865 return "mouse"; 30866 }); 30867 const roll = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 30868 if (source.value === "deviceOrientation") { 30869 let value; 30870 switch (screenOrientation.orientation) { 30871 case "landscape-primary": 30872 value = orientation.gamma / 90; 30873 break; 30874 case "landscape-secondary": 30875 value = -orientation.gamma / 90; 30876 break; 30877 case "portrait-primary": 30878 value = -orientation.beta / 90; 30879 break; 30880 case "portrait-secondary": 30881 value = orientation.beta / 90; 30882 break; 30883 default: 30884 value = -orientation.beta / 90; 30885 } 30886 return deviceOrientationRollAdjust(value); 30887 } else { 30888 const value = -(y.value - height.value / 2) / height.value; 30889 return mouseRollAdjust(value); 30890 } 30891 }); 30892 const tilt = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 30893 if (source.value === "deviceOrientation") { 30894 let value; 30895 switch (screenOrientation.orientation) { 30896 case "landscape-primary": 30897 value = orientation.beta / 90; 30898 break; 30899 case "landscape-secondary": 30900 value = -orientation.beta / 90; 30901 break; 30902 case "portrait-primary": 30903 value = orientation.gamma / 90; 30904 break; 30905 case "portrait-secondary": 30906 value = -orientation.gamma / 90; 30907 break; 30908 default: 30909 value = orientation.gamma / 90; 30910 } 30911 return deviceOrientationTiltAdjust(value); 30912 } else { 30913 const value = (x.value - width.value / 2) / width.value; 30914 return mouseTiltAdjust(value); 30915 } 30916 }); 30917 return { roll, tilt, source }; 30918} 30919 30920function useParentElement(element = useCurrentElement()) { 30921 const parentElement = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(); 30922 const update = () => { 30923 const el = unrefElement(element); 30924 if (el) 30925 parentElement.value = el.parentElement; 30926 }; 30927 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(update); 30928 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(() => (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(element), update); 30929 return parentElement; 30930} 30931 30932function usePerformanceObserver(options, callback) { 30933 const { 30934 window = defaultWindow, 30935 immediate = true, 30936 ...performanceOptions 30937 } = options; 30938 const isSupported = useSupported(() => window && "PerformanceObserver" in window); 30939 let observer; 30940 const stop = () => { 30941 observer == null ? undefined : observer.disconnect(); 30942 }; 30943 const start = () => { 30944 if (isSupported.value) { 30945 stop(); 30946 observer = new PerformanceObserver(callback); 30947 observer.observe(performanceOptions); 30948 } 30949 }; 30950 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(stop); 30951 if (immediate) 30952 start(); 30953 return { 30954 isSupported, 30955 start, 30956 stop 30957 }; 30958} 30959 30960const defaultState = { 30961 x: 0, 30962 y: 0, 30963 pointerId: 0, 30964 pressure: 0, 30965 tiltX: 0, 30966 tiltY: 0, 30967 width: 0, 30968 height: 0, 30969 twist: 0, 30970 pointerType: null 30971}; 30972const keys = /* @__PURE__ */ Object.keys(defaultState); 30973function usePointer(options = {}) { 30974 const { 30975 target = defaultWindow 30976 } = options; 30977 const isInside = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 30978 const state = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(options.initialValue || {}); 30979 Object.assign(state.value, defaultState, state.value); 30980 const handler = (event) => { 30981 isInside.value = true; 30982 if (options.pointerTypes && !options.pointerTypes.includes(event.pointerType)) 30983 return; 30984 state.value = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.objectPick)(event, keys, false); 30985 }; 30986 if (target) { 30987 const listenerOptions = { passive: true }; 30988 useEventListener(target, ["pointerdown", "pointermove", "pointerup"], handler, listenerOptions); 30989 useEventListener(target, "pointerleave", () => isInside.value = false, listenerOptions); 30990 } 30991 return { 30992 ...(0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRefs)(state), 30993 isInside 30994 }; 30995} 30996 30997function usePointerLock(target, options = {}) { 30998 const { document = defaultDocument } = options; 30999 const isSupported = useSupported(() => document && "pointerLockElement" in document); 31000 const element = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 31001 const triggerElement = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 31002 let targetElement; 31003 if (isSupported.value) { 31004 const listenerOptions = { passive: true }; 31005 useEventListener(document, "pointerlockchange", () => { 31006 var _a; 31007 const currentElement = (_a = document.pointerLockElement) != null ? _a : element.value; 31008 if (targetElement && currentElement === targetElement) { 31009 element.value = document.pointerLockElement; 31010 if (!element.value) 31011 targetElement = triggerElement.value = null; 31012 } 31013 }, listenerOptions); 31014 useEventListener(document, "pointerlockerror", () => { 31015 var _a; 31016 const currentElement = (_a = document.pointerLockElement) != null ? _a : element.value; 31017 if (targetElement && currentElement === targetElement) { 31018 const action = document.pointerLockElement ? "release" : "acquire"; 31019 throw new Error(`Failed to ${action} pointer lock.`); 31020 } 31021 }, listenerOptions); 31022 } 31023 async function lock(e) { 31024 var _a; 31025 if (!isSupported.value) 31026 throw new Error("Pointer Lock API is not supported by your browser."); 31027 triggerElement.value = e instanceof Event ? e.currentTarget : null; 31028 targetElement = e instanceof Event ? (_a = unrefElement(target)) != null ? _a : triggerElement.value : unrefElement(e); 31029 if (!targetElement) 31030 throw new Error("Target element undefined."); 31031 targetElement.requestPointerLock(); 31032 return await (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.until)(element).toBe(targetElement); 31033 } 31034 async function unlock() { 31035 if (!element.value) 31036 return false; 31037 document.exitPointerLock(); 31038 await (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.until)(element).toBeNull(); 31039 return true; 31040 } 31041 return { 31042 isSupported, 31043 element, 31044 triggerElement, 31045 lock, 31046 unlock 31047 }; 31048} 31049 31050function usePointerSwipe(target, options = {}) { 31051 const targetRef = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(target); 31052 const { 31053 threshold = 50, 31054 onSwipe, 31055 onSwipeEnd, 31056 onSwipeStart, 31057 disableTextSelect = false 31058 } = options; 31059 const posStart = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)({ x: 0, y: 0 }); 31060 const updatePosStart = (x, y) => { 31061 posStart.x = x; 31062 posStart.y = y; 31063 }; 31064 const posEnd = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)({ x: 0, y: 0 }); 31065 const updatePosEnd = (x, y) => { 31066 posEnd.x = x; 31067 posEnd.y = y; 31068 }; 31069 const distanceX = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => posStart.x - posEnd.x); 31070 const distanceY = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => posStart.y - posEnd.y); 31071 const { max, abs } = Math; 31072 const isThresholdExceeded = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => max(abs(distanceX.value), abs(distanceY.value)) >= threshold); 31073 const isSwiping = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 31074 const isPointerDown = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 31075 const direction = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 31076 if (!isThresholdExceeded.value) 31077 return "none"; 31078 if (abs(distanceX.value) > abs(distanceY.value)) { 31079 return distanceX.value > 0 ? "left" : "right"; 31080 } else { 31081 return distanceY.value > 0 ? "up" : "down"; 31082 } 31083 }); 31084 const eventIsAllowed = (e) => { 31085 var _a, _b, _c; 31086 const isReleasingButton = e.buttons === 0; 31087 const isPrimaryButton = e.buttons === 1; 31088 return (_c = (_b = (_a = options.pointerTypes) == null ? undefined : _a.includes(e.pointerType)) != null ? _b : isReleasingButton || isPrimaryButton) != null ? _c : true; 31089 }; 31090 const listenerOptions = { passive: true }; 31091 const stops = [ 31092 useEventListener(target, "pointerdown", (e) => { 31093 if (!eventIsAllowed(e)) 31094 return; 31095 isPointerDown.value = true; 31096 const eventTarget = e.target; 31097 eventTarget == null ? undefined : eventTarget.setPointerCapture(e.pointerId); 31098 const { clientX: x, clientY: y } = e; 31099 updatePosStart(x, y); 31100 updatePosEnd(x, y); 31101 onSwipeStart == null ? undefined : onSwipeStart(e); 31102 }, listenerOptions), 31103 useEventListener(target, "pointermove", (e) => { 31104 if (!eventIsAllowed(e)) 31105 return; 31106 if (!isPointerDown.value) 31107 return; 31108 const { clientX: x, clientY: y } = e; 31109 updatePosEnd(x, y); 31110 if (!isSwiping.value && isThresholdExceeded.value) 31111 isSwiping.value = true; 31112 if (isSwiping.value) 31113 onSwipe == null ? undefined : onSwipe(e); 31114 }, listenerOptions), 31115 useEventListener(target, "pointerup", (e) => { 31116 if (!eventIsAllowed(e)) 31117 return; 31118 if (isSwiping.value) 31119 onSwipeEnd == null ? undefined : onSwipeEnd(e, direction.value); 31120 isPointerDown.value = false; 31121 isSwiping.value = false; 31122 }, listenerOptions) 31123 ]; 31124 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => { 31125 var _a, _b, _c, _d, _e, _f, _g, _h; 31126 (_b = (_a = targetRef.value) == null ? undefined : _a.style) == null ? undefined : _b.setProperty("touch-action", "none"); 31127 if (disableTextSelect) { 31128 (_d = (_c = targetRef.value) == null ? undefined : _c.style) == null ? undefined : _d.setProperty("-webkit-user-select", "none"); 31129 (_f = (_e = targetRef.value) == null ? undefined : _e.style) == null ? undefined : _f.setProperty("-ms-user-select", "none"); 31130 (_h = (_g = targetRef.value) == null ? undefined : _g.style) == null ? undefined : _h.setProperty("user-select", "none"); 31131 } 31132 }); 31133 const stop = () => stops.forEach((s) => s()); 31134 return { 31135 isSwiping: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(isSwiping), 31136 direction: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(direction), 31137 posStart: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(posStart), 31138 posEnd: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(posEnd), 31139 distanceX, 31140 distanceY, 31141 stop 31142 }; 31143} 31144 31145function usePreferredColorScheme(options) { 31146 const isLight = useMediaQuery("(prefers-color-scheme: light)", options); 31147 const isDark = useMediaQuery("(prefers-color-scheme: dark)", options); 31148 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 31149 if (isDark.value) 31150 return "dark"; 31151 if (isLight.value) 31152 return "light"; 31153 return "no-preference"; 31154 }); 31155} 31156 31157function usePreferredContrast(options) { 31158 const isMore = useMediaQuery("(prefers-contrast: more)", options); 31159 const isLess = useMediaQuery("(prefers-contrast: less)", options); 31160 const isCustom = useMediaQuery("(prefers-contrast: custom)", options); 31161 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 31162 if (isMore.value) 31163 return "more"; 31164 if (isLess.value) 31165 return "less"; 31166 if (isCustom.value) 31167 return "custom"; 31168 return "no-preference"; 31169 }); 31170} 31171 31172function usePreferredLanguages(options = {}) { 31173 const { window = defaultWindow } = options; 31174 if (!window) 31175 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(["en"]); 31176 const navigator = window.navigator; 31177 const value = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(navigator.languages); 31178 useEventListener(window, "languagechange", () => { 31179 value.value = navigator.languages; 31180 }, { passive: true }); 31181 return value; 31182} 31183 31184function usePreferredReducedMotion(options) { 31185 const isReduced = useMediaQuery("(prefers-reduced-motion: reduce)", options); 31186 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 31187 if (isReduced.value) 31188 return "reduce"; 31189 return "no-preference"; 31190 }); 31191} 31192 31193function usePreferredReducedTransparency(options) { 31194 const isReduced = useMediaQuery("(prefers-reduced-transparency: reduce)", options); 31195 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 31196 if (isReduced.value) 31197 return "reduce"; 31198 return "no-preference"; 31199 }); 31200} 31201 31202function usePrevious(value, initialValue) { 31203 const previous = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(initialValue); 31204 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 31205 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(value), 31206 (_, oldValue) => { 31207 previous.value = oldValue; 31208 }, 31209 { flush: "sync" } 31210 ); 31211 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(previous); 31212} 31213 31214const topVarName = "--vueuse-safe-area-top"; 31215const rightVarName = "--vueuse-safe-area-right"; 31216const bottomVarName = "--vueuse-safe-area-bottom"; 31217const leftVarName = "--vueuse-safe-area-left"; 31218function useScreenSafeArea() { 31219 const top = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(""); 31220 const right = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(""); 31221 const bottom = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(""); 31222 const left = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(""); 31223 if (_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient) { 31224 const topCssVar = useCssVar(topVarName); 31225 const rightCssVar = useCssVar(rightVarName); 31226 const bottomCssVar = useCssVar(bottomVarName); 31227 const leftCssVar = useCssVar(leftVarName); 31228 topCssVar.value = "env(safe-area-inset-top, 0px)"; 31229 rightCssVar.value = "env(safe-area-inset-right, 0px)"; 31230 bottomCssVar.value = "env(safe-area-inset-bottom, 0px)"; 31231 leftCssVar.value = "env(safe-area-inset-left, 0px)"; 31232 update(); 31233 useEventListener("resize", (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useDebounceFn)(update), { passive: true }); 31234 } 31235 function update() { 31236 top.value = getValue(topVarName); 31237 right.value = getValue(rightVarName); 31238 bottom.value = getValue(bottomVarName); 31239 left.value = getValue(leftVarName); 31240 } 31241 return { 31242 top, 31243 right, 31244 bottom, 31245 left, 31246 update 31247 }; 31248} 31249function getValue(position) { 31250 return getComputedStyle(document.documentElement).getPropertyValue(position); 31251} 31252 31253function useScriptTag(src, onLoaded = _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.noop, options = {}) { 31254 const { 31255 immediate = true, 31256 manual = false, 31257 type = "text/javascript", 31258 async = true, 31259 crossOrigin, 31260 referrerPolicy, 31261 noModule, 31262 defer, 31263 document = defaultDocument, 31264 attrs = {} 31265 } = options; 31266 const scriptTag = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 31267 let _promise = null; 31268 const loadScript = (waitForScriptLoad) => new Promise((resolve, reject) => { 31269 const resolveWithElement = (el2) => { 31270 scriptTag.value = el2; 31271 resolve(el2); 31272 return el2; 31273 }; 31274 if (!document) { 31275 resolve(false); 31276 return; 31277 } 31278 let shouldAppend = false; 31279 let el = document.querySelector(`script[src="${(0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(src)}"]`); 31280 if (!el) { 31281 el = document.createElement("script"); 31282 el.type = type; 31283 el.async = async; 31284 el.src = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(src); 31285 if (defer) 31286 el.defer = defer; 31287 if (crossOrigin) 31288 el.crossOrigin = crossOrigin; 31289 if (noModule) 31290 el.noModule = noModule; 31291 if (referrerPolicy) 31292 el.referrerPolicy = referrerPolicy; 31293 Object.entries(attrs).forEach(([name, value]) => el == null ? undefined : el.setAttribute(name, value)); 31294 shouldAppend = true; 31295 } else if (el.hasAttribute("data-loaded")) { 31296 resolveWithElement(el); 31297 } 31298 const listenerOptions = { 31299 passive: true 31300 }; 31301 useEventListener(el, "error", (event) => reject(event), listenerOptions); 31302 useEventListener(el, "abort", (event) => reject(event), listenerOptions); 31303 useEventListener(el, "load", () => { 31304 el.setAttribute("data-loaded", "true"); 31305 onLoaded(el); 31306 resolveWithElement(el); 31307 }, listenerOptions); 31308 if (shouldAppend) 31309 el = document.head.appendChild(el); 31310 if (!waitForScriptLoad) 31311 resolveWithElement(el); 31312 }); 31313 const load = (waitForScriptLoad = true) => { 31314 if (!_promise) 31315 _promise = loadScript(waitForScriptLoad); 31316 return _promise; 31317 }; 31318 const unload = () => { 31319 if (!document) 31320 return; 31321 _promise = null; 31322 if (scriptTag.value) 31323 scriptTag.value = null; 31324 const el = document.querySelector(`script[src="${(0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(src)}"]`); 31325 if (el) 31326 document.head.removeChild(el); 31327 }; 31328 if (immediate && !manual) 31329 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(load); 31330 if (!manual) 31331 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnUnmounted)(unload); 31332 return { scriptTag, load, unload }; 31333} 31334 31335function checkOverflowScroll(ele) { 31336 const style = window.getComputedStyle(ele); 31337 if (style.overflowX === "scroll" || style.overflowY === "scroll" || style.overflowX === "auto" && ele.clientWidth < ele.scrollWidth || style.overflowY === "auto" && ele.clientHeight < ele.scrollHeight) { 31338 return true; 31339 } else { 31340 const parent = ele.parentNode; 31341 if (!parent || parent.tagName === "BODY") 31342 return false; 31343 return checkOverflowScroll(parent); 31344 } 31345} 31346function preventDefault(rawEvent) { 31347 const e = rawEvent || window.event; 31348 const _target = e.target; 31349 if (checkOverflowScroll(_target)) 31350 return false; 31351 if (e.touches.length > 1) 31352 return true; 31353 if (e.preventDefault) 31354 e.preventDefault(); 31355 return false; 31356} 31357const elInitialOverflow = /* @__PURE__ */ new WeakMap(); 31358function useScrollLock(element, initialState = false) { 31359 const isLocked = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialState); 31360 let stopTouchMoveListener = null; 31361 let initialOverflow = ""; 31362 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)((0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(element), (el) => { 31363 const target = resolveElement((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(el)); 31364 if (target) { 31365 const ele = target; 31366 if (!elInitialOverflow.get(ele)) 31367 elInitialOverflow.set(ele, ele.style.overflow); 31368 if (ele.style.overflow !== "hidden") 31369 initialOverflow = ele.style.overflow; 31370 if (ele.style.overflow === "hidden") 31371 return isLocked.value = true; 31372 if (isLocked.value) 31373 return ele.style.overflow = "hidden"; 31374 } 31375 }, { 31376 immediate: true 31377 }); 31378 const lock = () => { 31379 const el = resolveElement((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(element)); 31380 if (!el || isLocked.value) 31381 return; 31382 if (_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isIOS) { 31383 stopTouchMoveListener = useEventListener( 31384 el, 31385 "touchmove", 31386 (e) => { 31387 preventDefault(e); 31388 }, 31389 { passive: false } 31390 ); 31391 } 31392 el.style.overflow = "hidden"; 31393 isLocked.value = true; 31394 }; 31395 const unlock = () => { 31396 const el = resolveElement((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(element)); 31397 if (!el || !isLocked.value) 31398 return; 31399 if (_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isIOS) 31400 stopTouchMoveListener == null ? undefined : stopTouchMoveListener(); 31401 el.style.overflow = initialOverflow; 31402 elInitialOverflow.delete(el); 31403 isLocked.value = false; 31404 }; 31405 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(unlock); 31406 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 31407 get() { 31408 return isLocked.value; 31409 }, 31410 set(v) { 31411 if (v) 31412 lock(); 31413 else unlock(); 31414 } 31415 }); 31416} 31417 31418function useSessionStorage(key, initialValue, options = {}) { 31419 const { window = defaultWindow } = options; 31420 return useStorage(key, initialValue, window == null ? undefined : window.sessionStorage, options); 31421} 31422 31423function useShare(shareOptions = {}, options = {}) { 31424 const { navigator = defaultNavigator } = options; 31425 const _navigator = navigator; 31426 const isSupported = useSupported(() => _navigator && "canShare" in _navigator); 31427 const share = async (overrideOptions = {}) => { 31428 if (isSupported.value) { 31429 const data = { 31430 ...(0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(shareOptions), 31431 ...(0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(overrideOptions) 31432 }; 31433 let granted = true; 31434 if (data.files && _navigator.canShare) 31435 granted = _navigator.canShare({ files: data.files }); 31436 if (granted) 31437 return _navigator.share(data); 31438 } 31439 }; 31440 return { 31441 isSupported, 31442 share 31443 }; 31444} 31445 31446const defaultSortFn = (source, compareFn) => source.sort(compareFn); 31447const defaultCompare = (a, b) => a - b; 31448function useSorted(...args) { 31449 var _a, _b, _c, _d; 31450 const [source] = args; 31451 let compareFn = defaultCompare; 31452 let options = {}; 31453 if (args.length === 2) { 31454 if (typeof args[1] === "object") { 31455 options = args[1]; 31456 compareFn = (_a = options.compareFn) != null ? _a : defaultCompare; 31457 } else { 31458 compareFn = (_b = args[1]) != null ? _b : defaultCompare; 31459 } 31460 } else if (args.length > 2) { 31461 compareFn = (_c = args[1]) != null ? _c : defaultCompare; 31462 options = (_d = args[2]) != null ? _d : {}; 31463 } 31464 const { 31465 dirty = false, 31466 sortFn = defaultSortFn 31467 } = options; 31468 if (!dirty) 31469 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => sortFn([...(0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(source)], compareFn)); 31470 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watchEffect)(() => { 31471 const result = sortFn((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(source), compareFn); 31472 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.isRef)(source)) 31473 source.value = result; 31474 else 31475 source.splice(0, source.length, ...result); 31476 }); 31477 return source; 31478} 31479 31480function useSpeechRecognition(options = {}) { 31481 const { 31482 interimResults = true, 31483 continuous = true, 31484 maxAlternatives = 1, 31485 window = defaultWindow 31486 } = options; 31487 const lang = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(options.lang || "en-US"); 31488 const isListening = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 31489 const isFinal = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 31490 const result = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(""); 31491 const error = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(undefined); 31492 let recognition; 31493 const start = () => { 31494 if (!isListening.value) 31495 recognition == null ? undefined : recognition.start(); 31496 }; 31497 const stop = () => { 31498 if (isListening.value) 31499 recognition == null ? undefined : recognition.stop(); 31500 }; 31501 const toggle = (value = !isListening.value) => { 31502 if (value) { 31503 start(); 31504 } else { 31505 stop(); 31506 } 31507 }; 31508 const SpeechRecognition = window && (window.SpeechRecognition || window.webkitSpeechRecognition); 31509 const isSupported = useSupported(() => SpeechRecognition); 31510 if (isSupported.value) { 31511 recognition = new SpeechRecognition(); 31512 recognition.continuous = continuous; 31513 recognition.interimResults = interimResults; 31514 recognition.lang = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(lang); 31515 recognition.maxAlternatives = maxAlternatives; 31516 recognition.onstart = () => { 31517 isListening.value = true; 31518 isFinal.value = false; 31519 }; 31520 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(lang, (lang2) => { 31521 if (recognition && !isListening.value) 31522 recognition.lang = lang2; 31523 }); 31524 recognition.onresult = (event) => { 31525 const currentResult = event.results[event.resultIndex]; 31526 const { transcript } = currentResult[0]; 31527 isFinal.value = currentResult.isFinal; 31528 result.value = transcript; 31529 error.value = undefined; 31530 }; 31531 recognition.onerror = (event) => { 31532 error.value = event; 31533 }; 31534 recognition.onend = () => { 31535 isListening.value = false; 31536 recognition.lang = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(lang); 31537 }; 31538 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(isListening, () => { 31539 if (isListening.value) 31540 recognition.start(); 31541 else 31542 recognition.stop(); 31543 }); 31544 } 31545 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(() => { 31546 stop(); 31547 }); 31548 return { 31549 isSupported, 31550 isListening, 31551 isFinal, 31552 recognition, 31553 result, 31554 error, 31555 toggle, 31556 start, 31557 stop 31558 }; 31559} 31560 31561function useSpeechSynthesis(text, options = {}) { 31562 const { 31563 pitch = 1, 31564 rate = 1, 31565 volume = 1, 31566 window = defaultWindow 31567 } = options; 31568 const synth = window && window.speechSynthesis; 31569 const isSupported = useSupported(() => synth); 31570 const isPlaying = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 31571 const status = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)("init"); 31572 const spokenText = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(text || ""); 31573 const lang = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(options.lang || "en-US"); 31574 const error = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(undefined); 31575 const toggle = (value = !isPlaying.value) => { 31576 isPlaying.value = value; 31577 }; 31578 const bindEventsForUtterance = (utterance2) => { 31579 utterance2.lang = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(lang); 31580 utterance2.voice = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.voice) || null; 31581 utterance2.pitch = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(pitch); 31582 utterance2.rate = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(rate); 31583 utterance2.volume = volume; 31584 utterance2.onstart = () => { 31585 isPlaying.value = true; 31586 status.value = "play"; 31587 }; 31588 utterance2.onpause = () => { 31589 isPlaying.value = false; 31590 status.value = "pause"; 31591 }; 31592 utterance2.onresume = () => { 31593 isPlaying.value = true; 31594 status.value = "play"; 31595 }; 31596 utterance2.onend = () => { 31597 isPlaying.value = false; 31598 status.value = "end"; 31599 }; 31600 utterance2.onerror = (event) => { 31601 error.value = event; 31602 }; 31603 }; 31604 const utterance = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 31605 isPlaying.value = false; 31606 status.value = "init"; 31607 const newUtterance = new SpeechSynthesisUtterance(spokenText.value); 31608 bindEventsForUtterance(newUtterance); 31609 return newUtterance; 31610 }); 31611 const speak = () => { 31612 synth.cancel(); 31613 if (utterance) 31614 synth.speak(utterance.value); 31615 }; 31616 const stop = () => { 31617 synth.cancel(); 31618 isPlaying.value = false; 31619 }; 31620 if (isSupported.value) { 31621 bindEventsForUtterance(utterance.value); 31622 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(lang, (lang2) => { 31623 if (utterance.value && !isPlaying.value) 31624 utterance.value.lang = lang2; 31625 }); 31626 if (options.voice) { 31627 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(options.voice, () => { 31628 synth.cancel(); 31629 }); 31630 } 31631 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(isPlaying, () => { 31632 if (isPlaying.value) 31633 synth.resume(); 31634 else 31635 synth.pause(); 31636 }); 31637 } 31638 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(() => { 31639 isPlaying.value = false; 31640 }); 31641 return { 31642 isSupported, 31643 isPlaying, 31644 status, 31645 utterance, 31646 error, 31647 stop, 31648 toggle, 31649 speak 31650 }; 31651} 31652 31653function useStepper(steps, initialStep) { 31654 const stepsRef = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(steps); 31655 const stepNames = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => Array.isArray(stepsRef.value) ? stepsRef.value : Object.keys(stepsRef.value)); 31656 const index = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(stepNames.value.indexOf(initialStep != null ? initialStep : stepNames.value[0])); 31657 const current = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => at(index.value)); 31658 const isFirst = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => index.value === 0); 31659 const isLast = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => index.value === stepNames.value.length - 1); 31660 const next = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => stepNames.value[index.value + 1]); 31661 const previous = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => stepNames.value[index.value - 1]); 31662 function at(index2) { 31663 if (Array.isArray(stepsRef.value)) 31664 return stepsRef.value[index2]; 31665 return stepsRef.value[stepNames.value[index2]]; 31666 } 31667 function get(step) { 31668 if (!stepNames.value.includes(step)) 31669 return; 31670 return at(stepNames.value.indexOf(step)); 31671 } 31672 function goTo(step) { 31673 if (stepNames.value.includes(step)) 31674 index.value = stepNames.value.indexOf(step); 31675 } 31676 function goToNext() { 31677 if (isLast.value) 31678 return; 31679 index.value++; 31680 } 31681 function goToPrevious() { 31682 if (isFirst.value) 31683 return; 31684 index.value--; 31685 } 31686 function goBackTo(step) { 31687 if (isAfter(step)) 31688 goTo(step); 31689 } 31690 function isNext(step) { 31691 return stepNames.value.indexOf(step) === index.value + 1; 31692 } 31693 function isPrevious(step) { 31694 return stepNames.value.indexOf(step) === index.value - 1; 31695 } 31696 function isCurrent(step) { 31697 return stepNames.value.indexOf(step) === index.value; 31698 } 31699 function isBefore(step) { 31700 return index.value < stepNames.value.indexOf(step); 31701 } 31702 function isAfter(step) { 31703 return index.value > stepNames.value.indexOf(step); 31704 } 31705 return { 31706 steps: stepsRef, 31707 stepNames, 31708 index, 31709 current, 31710 next, 31711 previous, 31712 isFirst, 31713 isLast, 31714 at, 31715 get, 31716 goTo, 31717 goToNext, 31718 goToPrevious, 31719 goBackTo, 31720 isNext, 31721 isPrevious, 31722 isCurrent, 31723 isBefore, 31724 isAfter 31725 }; 31726} 31727 31728function useStorageAsync(key, initialValue, storage, options = {}) { 31729 var _a; 31730 const { 31731 flush = "pre", 31732 deep = true, 31733 listenToStorageChanges = true, 31734 writeDefaults = true, 31735 mergeDefaults = false, 31736 shallow, 31737 window = defaultWindow, 31738 eventFilter, 31739 onError = (e) => { 31740 console.error(e); 31741 } 31742 } = options; 31743 const rawInit = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(initialValue); 31744 const type = guessSerializerType(rawInit); 31745 const data = (shallow ? vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef : vue__WEBPACK_IMPORTED_MODULE_1__.ref)((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(initialValue)); 31746 const serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type]; 31747 if (!storage) { 31748 try { 31749 storage = getSSRHandler("getDefaultStorageAsync", () => { 31750 var _a2; 31751 return (_a2 = defaultWindow) == null ? void 0 : _a2.localStorage; 31752 })(); 31753 } catch (e) { 31754 onError(e); 31755 } 31756 } 31757 async function read(event) { 31758 if (!storage || event && event.key !== key) 31759 return; 31760 try { 31761 const rawValue = event ? event.newValue : await storage.getItem(key); 31762 if (rawValue == null) { 31763 data.value = rawInit; 31764 if (writeDefaults && rawInit !== null) 31765 await storage.setItem(key, await serializer.write(rawInit)); 31766 } else if (mergeDefaults) { 31767 const value = await serializer.read(rawValue); 31768 if (typeof mergeDefaults === "function") 31769 data.value = mergeDefaults(value, rawInit); 31770 else if (type === "object" && !Array.isArray(value)) 31771 data.value = { ...rawInit, ...value }; 31772 else data.value = value; 31773 } else { 31774 data.value = await serializer.read(rawValue); 31775 } 31776 } catch (e) { 31777 onError(e); 31778 } 31779 } 31780 read(); 31781 if (window && listenToStorageChanges) 31782 useEventListener(window, "storage", (e) => Promise.resolve().then(() => read(e)), { passive: true }); 31783 if (storage) { 31784 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.watchWithFilter)( 31785 data, 31786 async () => { 31787 try { 31788 if (data.value == null) 31789 await storage.removeItem(key); 31790 else 31791 await storage.setItem(key, await serializer.write(data.value)); 31792 } catch (e) { 31793 onError(e); 31794 } 31795 }, 31796 { 31797 flush, 31798 deep, 31799 eventFilter 31800 } 31801 ); 31802 } 31803 return data; 31804} 31805 31806let _id = 0; 31807function useStyleTag(css, options = {}) { 31808 const isLoaded = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 31809 const { 31810 document = defaultDocument, 31811 immediate = true, 31812 manual = false, 31813 id = `vueuse_styletag_${++_id}` 31814 } = options; 31815 const cssRef = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(css); 31816 let stop = () => { 31817 }; 31818 const load = () => { 31819 if (!document) 31820 return; 31821 const el = document.getElementById(id) || document.createElement("style"); 31822 if (!el.isConnected) { 31823 el.id = id; 31824 if (options.media) 31825 el.media = options.media; 31826 document.head.appendChild(el); 31827 } 31828 if (isLoaded.value) 31829 return; 31830 stop = (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 31831 cssRef, 31832 (value) => { 31833 el.textContent = value; 31834 }, 31835 { immediate: true } 31836 ); 31837 isLoaded.value = true; 31838 }; 31839 const unload = () => { 31840 if (!document || !isLoaded.value) 31841 return; 31842 stop(); 31843 document.head.removeChild(document.getElementById(id)); 31844 isLoaded.value = false; 31845 }; 31846 if (immediate && !manual) 31847 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(load); 31848 if (!manual) 31849 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(unload); 31850 return { 31851 id, 31852 css: cssRef, 31853 unload, 31854 load, 31855 isLoaded: (0,vue__WEBPACK_IMPORTED_MODULE_1__.readonly)(isLoaded) 31856 }; 31857} 31858 31859function useSwipe(target, options = {}) { 31860 const { 31861 threshold = 50, 31862 onSwipe, 31863 onSwipeEnd, 31864 onSwipeStart, 31865 passive = true 31866 } = options; 31867 const coordsStart = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)({ x: 0, y: 0 }); 31868 const coordsEnd = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)({ x: 0, y: 0 }); 31869 const diffX = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => coordsStart.x - coordsEnd.x); 31870 const diffY = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => coordsStart.y - coordsEnd.y); 31871 const { max, abs } = Math; 31872 const isThresholdExceeded = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => max(abs(diffX.value), abs(diffY.value)) >= threshold); 31873 const isSwiping = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 31874 const direction = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 31875 if (!isThresholdExceeded.value) 31876 return "none"; 31877 if (abs(diffX.value) > abs(diffY.value)) { 31878 return diffX.value > 0 ? "left" : "right"; 31879 } else { 31880 return diffY.value > 0 ? "up" : "down"; 31881 } 31882 }); 31883 const getTouchEventCoords = (e) => [e.touches[0].clientX, e.touches[0].clientY]; 31884 const updateCoordsStart = (x, y) => { 31885 coordsStart.x = x; 31886 coordsStart.y = y; 31887 }; 31888 const updateCoordsEnd = (x, y) => { 31889 coordsEnd.x = x; 31890 coordsEnd.y = y; 31891 }; 31892 const listenerOptions = { passive, capture: !passive }; 31893 const onTouchEnd = (e) => { 31894 if (isSwiping.value) 31895 onSwipeEnd == null ? undefined : onSwipeEnd(e, direction.value); 31896 isSwiping.value = false; 31897 }; 31898 const stops = [ 31899 useEventListener(target, "touchstart", (e) => { 31900 if (e.touches.length !== 1) 31901 return; 31902 const [x, y] = getTouchEventCoords(e); 31903 updateCoordsStart(x, y); 31904 updateCoordsEnd(x, y); 31905 onSwipeStart == null ? undefined : onSwipeStart(e); 31906 }, listenerOptions), 31907 useEventListener(target, "touchmove", (e) => { 31908 if (e.touches.length !== 1) 31909 return; 31910 const [x, y] = getTouchEventCoords(e); 31911 updateCoordsEnd(x, y); 31912 if (listenerOptions.capture && !listenerOptions.passive && Math.abs(diffX.value) > Math.abs(diffY.value)) 31913 e.preventDefault(); 31914 if (!isSwiping.value && isThresholdExceeded.value) 31915 isSwiping.value = true; 31916 if (isSwiping.value) 31917 onSwipe == null ? undefined : onSwipe(e); 31918 }, listenerOptions), 31919 useEventListener(target, ["touchend", "touchcancel"], onTouchEnd, listenerOptions) 31920 ]; 31921 const stop = () => stops.forEach((s) => s()); 31922 return { 31923 isSwiping, 31924 direction, 31925 coordsStart, 31926 coordsEnd, 31927 lengthX: diffX, 31928 lengthY: diffY, 31929 stop, 31930 // TODO: Remove in the next major version 31931 isPassiveEventSupported: true 31932 }; 31933} 31934 31935function useTemplateRefsList() { 31936 const refs = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)([]); 31937 refs.value.set = (el) => { 31938 if (el) 31939 refs.value.push(el); 31940 }; 31941 (0,vue__WEBPACK_IMPORTED_MODULE_1__.onBeforeUpdate)(() => { 31942 refs.value.length = 0; 31943 }); 31944 return refs; 31945} 31946 31947function useTextDirection(options = {}) { 31948 const { 31949 document = defaultDocument, 31950 selector = "html", 31951 observe = false, 31952 initialValue = "ltr" 31953 } = options; 31954 function getValue() { 31955 var _a, _b; 31956 return (_b = (_a = document == null ? undefined : document.querySelector(selector)) == null ? undefined : _a.getAttribute("dir")) != null ? _b : initialValue; 31957 } 31958 const dir = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(getValue()); 31959 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(() => dir.value = getValue()); 31960 if (observe && document) { 31961 useMutationObserver( 31962 document.querySelector(selector), 31963 () => dir.value = getValue(), 31964 { attributes: true } 31965 ); 31966 } 31967 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 31968 get() { 31969 return dir.value; 31970 }, 31971 set(v) { 31972 var _a, _b; 31973 dir.value = v; 31974 if (!document) 31975 return; 31976 if (dir.value) 31977 (_a = document.querySelector(selector)) == null ? undefined : _a.setAttribute("dir", dir.value); 31978 else 31979 (_b = document.querySelector(selector)) == null ? undefined : _b.removeAttribute("dir"); 31980 } 31981 }); 31982} 31983 31984function getRangesFromSelection(selection) { 31985 var _a; 31986 const rangeCount = (_a = selection.rangeCount) != null ? _a : 0; 31987 return Array.from({ length: rangeCount }, (_, i) => selection.getRangeAt(i)); 31988} 31989function useTextSelection(options = {}) { 31990 const { 31991 window = defaultWindow 31992 } = options; 31993 const selection = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 31994 const text = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 31995 var _a, _b; 31996 return (_b = (_a = selection.value) == null ? undefined : _a.toString()) != null ? _b : ""; 31997 }); 31998 const ranges = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => selection.value ? getRangesFromSelection(selection.value) : []); 31999 const rects = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => ranges.value.map((range) => range.getBoundingClientRect())); 32000 function onSelectionChange() { 32001 selection.value = null; 32002 if (window) 32003 selection.value = window.getSelection(); 32004 } 32005 if (window) 32006 useEventListener(window.document, "selectionchange", onSelectionChange, { passive: true }); 32007 return { 32008 text, 32009 rects, 32010 ranges, 32011 selection 32012 }; 32013} 32014 32015function useTextareaAutosize(options) { 32016 var _a, _b; 32017 const textarea = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(options == null ? undefined : options.element); 32018 const input = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)((_a = options == null ? undefined : options.input) != null ? _a : ""); 32019 const styleProp = (_b = options == null ? undefined : options.styleProp) != null ? _b : "height"; 32020 const textareaScrollHeight = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(1); 32021 const textareaOldWidth = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(0); 32022 function triggerResize() { 32023 var _a2; 32024 if (!textarea.value) 32025 return; 32026 let height = ""; 32027 textarea.value.style[styleProp] = "1px"; 32028 textareaScrollHeight.value = (_a2 = textarea.value) == null ? undefined : _a2.scrollHeight; 32029 const _styleTarget = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options == null ? undefined : options.styleTarget); 32030 if (_styleTarget) 32031 _styleTarget.style[styleProp] = `${textareaScrollHeight.value}px`; 32032 else 32033 height = `${textareaScrollHeight.value}px`; 32034 textarea.value.style[styleProp] = height; 32035 } 32036 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)([input, textarea], () => (0,vue__WEBPACK_IMPORTED_MODULE_1__.nextTick)(triggerResize), { immediate: true }); 32037 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(textareaScrollHeight, () => { 32038 var _a2; 32039 return (_a2 = options == null ? undefined : options.onResize) == null ? undefined : _a2.call(options); 32040 }); 32041 useResizeObserver(textarea, ([{ contentRect }]) => { 32042 if (textareaOldWidth.value === contentRect.width) 32043 return; 32044 textareaOldWidth.value = contentRect.width; 32045 triggerResize(); 32046 }); 32047 if (options == null ? undefined : options.watch) 32048 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(options.watch, triggerResize, { immediate: true, deep: true }); 32049 return { 32050 textarea, 32051 input, 32052 triggerResize 32053 }; 32054} 32055 32056function useThrottledRefHistory(source, options = {}) { 32057 const { throttle = 200, trailing = true } = options; 32058 const filter = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.throttleFilter)(throttle, trailing); 32059 const history = useRefHistory(source, { ...options, eventFilter: filter }); 32060 return { 32061 ...history 32062 }; 32063} 32064 32065const DEFAULT_UNITS = [ 32066 { max: 6e4, value: 1e3, name: "second" }, 32067 { max: 276e4, value: 6e4, name: "minute" }, 32068 { max: 72e6, value: 36e5, name: "hour" }, 32069 { max: 5184e5, value: 864e5, name: "day" }, 32070 { max: 24192e5, value: 6048e5, name: "week" }, 32071 { max: 28512e6, value: 2592e6, name: "month" }, 32072 { max: Number.POSITIVE_INFINITY, value: 31536e6, name: "year" } 32073]; 32074const DEFAULT_MESSAGES = { 32075 justNow: "just now", 32076 past: (n) => n.match(/\d/) ? `${n} ago` : n, 32077 future: (n) => n.match(/\d/) ? `in ${n}` : n, 32078 month: (n, past) => n === 1 ? past ? "last month" : "next month" : `${n} month${n > 1 ? "s" : ""}`, 32079 year: (n, past) => n === 1 ? past ? "last year" : "next year" : `${n} year${n > 1 ? "s" : ""}`, 32080 day: (n, past) => n === 1 ? past ? "yesterday" : "tomorrow" : `${n} day${n > 1 ? "s" : ""}`, 32081 week: (n, past) => n === 1 ? past ? "last week" : "next week" : `${n} week${n > 1 ? "s" : ""}`, 32082 hour: (n) => `${n} hour${n > 1 ? "s" : ""}`, 32083 minute: (n) => `${n} minute${n > 1 ? "s" : ""}`, 32084 second: (n) => `${n} second${n > 1 ? "s" : ""}`, 32085 invalid: "" 32086}; 32087function DEFAULT_FORMATTER(date) { 32088 return date.toISOString().slice(0, 10); 32089} 32090function useTimeAgo(time, options = {}) { 32091 const { 32092 controls: exposeControls = false, 32093 updateInterval = 3e4 32094 } = options; 32095 const { now, ...controls } = useNow({ interval: updateInterval, controls: true }); 32096 const timeAgo = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => formatTimeAgo(new Date((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(time)), options, (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(now))); 32097 if (exposeControls) { 32098 return { 32099 timeAgo, 32100 ...controls 32101 }; 32102 } else { 32103 return timeAgo; 32104 } 32105} 32106function formatTimeAgo(from, options = {}, now = Date.now()) { 32107 var _a; 32108 const { 32109 max, 32110 messages = DEFAULT_MESSAGES, 32111 fullDateFormatter = DEFAULT_FORMATTER, 32112 units = DEFAULT_UNITS, 32113 showSecond = false, 32114 rounding = "round" 32115 } = options; 32116 const roundFn = typeof rounding === "number" ? (n) => +n.toFixed(rounding) : Math[rounding]; 32117 const diff = +now - +from; 32118 const absDiff = Math.abs(diff); 32119 function getValue(diff2, unit) { 32120 return roundFn(Math.abs(diff2) / unit.value); 32121 } 32122 function format(diff2, unit) { 32123 const val = getValue(diff2, unit); 32124 const past = diff2 > 0; 32125 const str = applyFormat(unit.name, val, past); 32126 return applyFormat(past ? "past" : "future", str, past); 32127 } 32128 function applyFormat(name, val, isPast) { 32129 const formatter = messages[name]; 32130 if (typeof formatter === "function") 32131 return formatter(val, isPast); 32132 return formatter.replace("{0}", val.toString()); 32133 } 32134 if (absDiff < 6e4 && !showSecond) 32135 return messages.justNow; 32136 if (typeof max === "number" && absDiff > max) 32137 return fullDateFormatter(new Date(from)); 32138 if (typeof max === "string") { 32139 const unitMax = (_a = units.find((i) => i.name === max)) == null ? undefined : _a.max; 32140 if (unitMax && absDiff > unitMax) 32141 return fullDateFormatter(new Date(from)); 32142 } 32143 for (const [idx, unit] of units.entries()) { 32144 const val = getValue(diff, unit); 32145 if (val <= 0 && units[idx - 1]) 32146 return format(diff, units[idx - 1]); 32147 if (absDiff < unit.max) 32148 return format(diff, unit); 32149 } 32150 return messages.invalid; 32151} 32152 32153function useTimeoutPoll(fn, interval, options = {}) { 32154 const { 32155 immediate = true 32156 } = options; 32157 const { start } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useTimeoutFn)(loop, interval, { immediate: false }); 32158 const isActive = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 32159 async function loop() { 32160 if (!isActive.value) 32161 return; 32162 await fn(); 32163 start(); 32164 } 32165 function resume() { 32166 if (!isActive.value) { 32167 isActive.value = true; 32168 loop(); 32169 } 32170 } 32171 function pause() { 32172 isActive.value = false; 32173 } 32174 if (immediate && _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient) 32175 resume(); 32176 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(pause); 32177 return { 32178 isActive, 32179 pause, 32180 resume 32181 }; 32182} 32183 32184function useTimestamp(options = {}) { 32185 const { 32186 controls: exposeControls = false, 32187 offset = 0, 32188 immediate = true, 32189 interval = "requestAnimationFrame", 32190 callback 32191 } = options; 32192 const ts = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)((0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.timestamp)() + offset); 32193 const update = () => ts.value = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.timestamp)() + offset; 32194 const cb = callback ? () => { 32195 update(); 32196 callback(ts.value); 32197 } : update; 32198 const controls = interval === "requestAnimationFrame" ? useRafFn(cb, { immediate }) : (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useIntervalFn)(cb, interval, { immediate }); 32199 if (exposeControls) { 32200 return { 32201 timestamp: ts, 32202 ...controls 32203 }; 32204 } else { 32205 return ts; 32206 } 32207} 32208 32209function useTitle(newTitle = null, options = {}) { 32210 var _a, _b, _c; 32211 const { 32212 document = defaultDocument, 32213 restoreOnUnmount = (t) => t 32214 } = options; 32215 const originalTitle = (_a = document == null ? undefined : document.title) != null ? _a : ""; 32216 const title = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)((_b = newTitle != null ? newTitle : document == null ? undefined : document.title) != null ? _b : null); 32217 const isReadonly = !!(newTitle && typeof newTitle === "function"); 32218 function format(t) { 32219 if (!("titleTemplate" in options)) 32220 return t; 32221 const template = options.titleTemplate || "%s"; 32222 return typeof template === "function" ? template(t) : (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(template).replace(/%s/g, t); 32223 } 32224 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 32225 title, 32226 (newValue, oldValue) => { 32227 if (newValue !== oldValue && document) 32228 document.title = format(newValue != null ? newValue : ""); 32229 }, 32230 { immediate: true } 32231 ); 32232 if (options.observe && !options.titleTemplate && document && !isReadonly) { 32233 useMutationObserver( 32234 (_c = document.head) == null ? undefined : _c.querySelector("title"), 32235 () => { 32236 if (document && document.title !== title.value) 32237 title.value = format(document.title); 32238 }, 32239 { childList: true } 32240 ); 32241 } 32242 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnBeforeUnmount)(() => { 32243 if (restoreOnUnmount) { 32244 const restoredTitle = restoreOnUnmount(originalTitle, title.value || ""); 32245 if (restoredTitle != null && document) 32246 document.title = restoredTitle; 32247 } 32248 }); 32249 return title; 32250} 32251 32252const _TransitionPresets = { 32253 easeInSine: [0.12, 0, 0.39, 0], 32254 easeOutSine: [0.61, 1, 0.88, 1], 32255 easeInOutSine: [0.37, 0, 0.63, 1], 32256 easeInQuad: [0.11, 0, 0.5, 0], 32257 easeOutQuad: [0.5, 1, 0.89, 1], 32258 easeInOutQuad: [0.45, 0, 0.55, 1], 32259 easeInCubic: [0.32, 0, 0.67, 0], 32260 easeOutCubic: [0.33, 1, 0.68, 1], 32261 easeInOutCubic: [0.65, 0, 0.35, 1], 32262 easeInQuart: [0.5, 0, 0.75, 0], 32263 easeOutQuart: [0.25, 1, 0.5, 1], 32264 easeInOutQuart: [0.76, 0, 0.24, 1], 32265 easeInQuint: [0.64, 0, 0.78, 0], 32266 easeOutQuint: [0.22, 1, 0.36, 1], 32267 easeInOutQuint: [0.83, 0, 0.17, 1], 32268 easeInExpo: [0.7, 0, 0.84, 0], 32269 easeOutExpo: [0.16, 1, 0.3, 1], 32270 easeInOutExpo: [0.87, 0, 0.13, 1], 32271 easeInCirc: [0.55, 0, 1, 0.45], 32272 easeOutCirc: [0, 0.55, 0.45, 1], 32273 easeInOutCirc: [0.85, 0, 0.15, 1], 32274 easeInBack: [0.36, 0, 0.66, -0.56], 32275 easeOutBack: [0.34, 1.56, 0.64, 1], 32276 easeInOutBack: [0.68, -0.6, 0.32, 1.6] 32277}; 32278const TransitionPresets = /* @__PURE__ */ Object.assign({}, { linear: _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.identity }, _TransitionPresets); 32279function createEasingFunction([p0, p1, p2, p3]) { 32280 const a = (a1, a2) => 1 - 3 * a2 + 3 * a1; 32281 const b = (a1, a2) => 3 * a2 - 6 * a1; 32282 const c = (a1) => 3 * a1; 32283 const calcBezier = (t, a1, a2) => ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t; 32284 const getSlope = (t, a1, a2) => 3 * a(a1, a2) * t * t + 2 * b(a1, a2) * t + c(a1); 32285 const getTforX = (x) => { 32286 let aGuessT = x; 32287 for (let i = 0; i < 4; ++i) { 32288 const currentSlope = getSlope(aGuessT, p0, p2); 32289 if (currentSlope === 0) 32290 return aGuessT; 32291 const currentX = calcBezier(aGuessT, p0, p2) - x; 32292 aGuessT -= currentX / currentSlope; 32293 } 32294 return aGuessT; 32295 }; 32296 return (x) => p0 === p1 && p2 === p3 ? x : calcBezier(getTforX(x), p1, p3); 32297} 32298function lerp(a, b, alpha) { 32299 return a + alpha * (b - a); 32300} 32301function toVec(t) { 32302 return (typeof t === "number" ? [t] : t) || []; 32303} 32304function executeTransition(source, from, to, options = {}) { 32305 var _a, _b; 32306 const fromVal = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(from); 32307 const toVal = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(to); 32308 const v1 = toVec(fromVal); 32309 const v2 = toVec(toVal); 32310 const duration = (_a = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.duration)) != null ? _a : 1e3; 32311 const startedAt = Date.now(); 32312 const endAt = Date.now() + duration; 32313 const trans = typeof options.transition === "function" ? options.transition : (_b = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.transition)) != null ? _b : _vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.identity; 32314 const ease = typeof trans === "function" ? trans : createEasingFunction(trans); 32315 return new Promise((resolve) => { 32316 source.value = fromVal; 32317 const tick = () => { 32318 var _a2; 32319 if ((_a2 = options.abort) == null ? undefined : _a2.call(options)) { 32320 resolve(); 32321 return; 32322 } 32323 const now = Date.now(); 32324 const alpha = ease((now - startedAt) / duration); 32325 const arr = toVec(source.value).map((n, i) => lerp(v1[i], v2[i], alpha)); 32326 if (Array.isArray(source.value)) 32327 source.value = arr.map((n, i) => { 32328 var _a3, _b2; 32329 return lerp((_a3 = v1[i]) != null ? _a3 : 0, (_b2 = v2[i]) != null ? _b2 : 0, alpha); 32330 }); 32331 else if (typeof source.value === "number") 32332 source.value = arr[0]; 32333 if (now < endAt) { 32334 requestAnimationFrame(tick); 32335 } else { 32336 source.value = toVal; 32337 resolve(); 32338 } 32339 }; 32340 tick(); 32341 }); 32342} 32343function useTransition(source, options = {}) { 32344 let currentId = 0; 32345 const sourceVal = () => { 32346 const v = (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(source); 32347 return typeof v === "number" ? v : v.map(vue__WEBPACK_IMPORTED_MODULE_1__.toValue); 32348 }; 32349 const outputRef = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(sourceVal()); 32350 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(sourceVal, async (to) => { 32351 var _a, _b; 32352 if ((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.disabled)) 32353 return; 32354 const id = ++currentId; 32355 if (options.delay) 32356 await (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.promiseTimeout)((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.delay)); 32357 if (id !== currentId) 32358 return; 32359 const toVal = Array.isArray(to) ? to.map(vue__WEBPACK_IMPORTED_MODULE_1__.toValue) : (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(to); 32360 (_a = options.onStarted) == null ? undefined : _a.call(options); 32361 await executeTransition(outputRef, outputRef.value, toVal, { 32362 ...options, 32363 abort: () => { 32364 var _a2; 32365 return id !== currentId || ((_a2 = options.abort) == null ? undefined : _a2.call(options)); 32366 } 32367 }); 32368 (_b = options.onFinished) == null ? undefined : _b.call(options); 32369 }, { deep: true }); 32370 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(() => (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.disabled), (disabled) => { 32371 if (disabled) { 32372 currentId++; 32373 outputRef.value = sourceVal(); 32374 } 32375 }); 32376 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(() => { 32377 currentId++; 32378 }); 32379 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(options.disabled) ? sourceVal() : outputRef.value); 32380} 32381 32382function useUrlSearchParams(mode = "history", options = {}) { 32383 const { 32384 initialValue = {}, 32385 removeNullishValues = true, 32386 removeFalsyValues = false, 32387 write: enableWrite = true, 32388 writeMode = "replace", 32389 window = defaultWindow 32390 } = options; 32391 if (!window) 32392 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)(initialValue); 32393 const state = (0,vue__WEBPACK_IMPORTED_MODULE_1__.reactive)({}); 32394 function getRawParams() { 32395 if (mode === "history") { 32396 return window.location.search || ""; 32397 } else if (mode === "hash") { 32398 const hash = window.location.hash || ""; 32399 const index = hash.indexOf("?"); 32400 return index > 0 ? hash.slice(index) : ""; 32401 } else { 32402 return (window.location.hash || "").replace(/^#/, ""); 32403 } 32404 } 32405 function constructQuery(params) { 32406 const stringified = params.toString(); 32407 if (mode === "history") 32408 return `${stringified ? `?${stringified}` : ""}${window.location.hash || ""}`; 32409 if (mode === "hash-params") 32410 return `${window.location.search || ""}${stringified ? `#${stringified}` : ""}`; 32411 const hash = window.location.hash || "#"; 32412 const index = hash.indexOf("?"); 32413 if (index > 0) 32414 return `${window.location.search || ""}${hash.slice(0, index)}${stringified ? `?${stringified}` : ""}`; 32415 return `${window.location.search || ""}${hash}${stringified ? `?${stringified}` : ""}`; 32416 } 32417 function read() { 32418 return new URLSearchParams(getRawParams()); 32419 } 32420 function updateState(params) { 32421 const unusedKeys = new Set(Object.keys(state)); 32422 for (const key of params.keys()) { 32423 const paramsForKey = params.getAll(key); 32424 state[key] = paramsForKey.length > 1 ? paramsForKey : params.get(key) || ""; 32425 unusedKeys.delete(key); 32426 } 32427 Array.from(unusedKeys).forEach((key) => delete state[key]); 32428 } 32429 const { pause, resume } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.pausableWatch)( 32430 state, 32431 () => { 32432 const params = new URLSearchParams(""); 32433 Object.keys(state).forEach((key) => { 32434 const mapEntry = state[key]; 32435 if (Array.isArray(mapEntry)) 32436 mapEntry.forEach((value) => params.append(key, value)); 32437 else if (removeNullishValues && mapEntry == null) 32438 params.delete(key); 32439 else if (removeFalsyValues && !mapEntry) 32440 params.delete(key); 32441 else 32442 params.set(key, mapEntry); 32443 }); 32444 write(params, false); 32445 }, 32446 { deep: true } 32447 ); 32448 function write(params, shouldUpdate) { 32449 pause(); 32450 if (shouldUpdate) 32451 updateState(params); 32452 if (writeMode === "replace") { 32453 window.history.replaceState( 32454 window.history.state, 32455 window.document.title, 32456 window.location.pathname + constructQuery(params) 32457 ); 32458 } else { 32459 window.history.pushState( 32460 window.history.state, 32461 window.document.title, 32462 window.location.pathname + constructQuery(params) 32463 ); 32464 } 32465 resume(); 32466 } 32467 function onChanged() { 32468 if (!enableWrite) 32469 return; 32470 write(read(), true); 32471 } 32472 const listenerOptions = { passive: true }; 32473 useEventListener(window, "popstate", onChanged, listenerOptions); 32474 if (mode !== "history") 32475 useEventListener(window, "hashchange", onChanged, listenerOptions); 32476 const initial = read(); 32477 if (initial.keys().next().value) 32478 updateState(initial); 32479 else 32480 Object.assign(state, initialValue); 32481 return state; 32482} 32483 32484function useUserMedia(options = {}) { 32485 var _a, _b; 32486 const enabled = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)((_a = options.enabled) != null ? _a : false); 32487 const autoSwitch = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)((_b = options.autoSwitch) != null ? _b : true); 32488 const constraints = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(options.constraints); 32489 const { navigator = defaultNavigator } = options; 32490 const isSupported = useSupported(() => { 32491 var _a2; 32492 return (_a2 = navigator == null ? undefined : navigator.mediaDevices) == null ? undefined : _a2.getUserMedia; 32493 }); 32494 const stream = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(); 32495 function getDeviceOptions(type) { 32496 switch (type) { 32497 case "video": { 32498 if (constraints.value) 32499 return constraints.value.video || false; 32500 break; 32501 } 32502 case "audio": { 32503 if (constraints.value) 32504 return constraints.value.audio || false; 32505 break; 32506 } 32507 } 32508 } 32509 async function _start() { 32510 if (!isSupported.value || stream.value) 32511 return; 32512 stream.value = await navigator.mediaDevices.getUserMedia({ 32513 video: getDeviceOptions("video"), 32514 audio: getDeviceOptions("audio") 32515 }); 32516 return stream.value; 32517 } 32518 function _stop() { 32519 var _a2; 32520 (_a2 = stream.value) == null ? undefined : _a2.getTracks().forEach((t) => t.stop()); 32521 stream.value = undefined; 32522 } 32523 function stop() { 32524 _stop(); 32525 enabled.value = false; 32526 } 32527 async function start() { 32528 await _start(); 32529 if (stream.value) 32530 enabled.value = true; 32531 return stream.value; 32532 } 32533 async function restart() { 32534 _stop(); 32535 return await start(); 32536 } 32537 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 32538 enabled, 32539 (v) => { 32540 if (v) 32541 _start(); 32542 else _stop(); 32543 }, 32544 { immediate: true } 32545 ); 32546 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 32547 constraints, 32548 () => { 32549 if (autoSwitch.value && stream.value) 32550 restart(); 32551 }, 32552 { immediate: true } 32553 ); 32554 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(() => { 32555 stop(); 32556 }); 32557 return { 32558 isSupported, 32559 stream, 32560 start, 32561 stop, 32562 restart, 32563 constraints, 32564 enabled, 32565 autoSwitch 32566 }; 32567} 32568 32569function useVModel(props, key, emit, options = {}) { 32570 var _a, _b, _c; 32571 const { 32572 clone = false, 32573 passive = false, 32574 eventName, 32575 deep = false, 32576 defaultValue, 32577 shouldEmit 32578 } = options; 32579 const vm = (0,vue__WEBPACK_IMPORTED_MODULE_1__.getCurrentInstance)(); 32580 const _emit = emit || (vm == null ? undefined : vm.emit) || ((_a = vm == null ? undefined : vm.$emit) == null ? undefined : _a.bind(vm)) || ((_c = (_b = vm == null ? undefined : vm.proxy) == null ? undefined : _b.$emit) == null ? undefined : _c.bind(vm == null ? undefined : vm.proxy)); 32581 let event = eventName; 32582 if (!key) { 32583 key = "modelValue"; 32584 } 32585 event = event || `update:${key.toString()}`; 32586 const cloneFn = (val) => !clone ? val : typeof clone === "function" ? clone(val) : cloneFnJSON(val); 32587 const getValue = () => (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isDef)(props[key]) ? cloneFn(props[key]) : defaultValue; 32588 const triggerEmit = (value) => { 32589 if (shouldEmit) { 32590 if (shouldEmit(value)) 32591 _emit(event, value); 32592 } else { 32593 _emit(event, value); 32594 } 32595 }; 32596 if (passive) { 32597 const initialValue = getValue(); 32598 const proxy = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialValue); 32599 let isUpdating = false; 32600 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 32601 () => props[key], 32602 (v) => { 32603 if (!isUpdating) { 32604 isUpdating = true; 32605 proxy.value = cloneFn(v); 32606 (0,vue__WEBPACK_IMPORTED_MODULE_1__.nextTick)(() => isUpdating = false); 32607 } 32608 } 32609 ); 32610 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)( 32611 proxy, 32612 (v) => { 32613 if (!isUpdating && (v !== props[key] || deep)) 32614 triggerEmit(v); 32615 }, 32616 { deep } 32617 ); 32618 return proxy; 32619 } else { 32620 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)({ 32621 get() { 32622 return getValue(); 32623 }, 32624 set(value) { 32625 triggerEmit(value); 32626 } 32627 }); 32628 } 32629} 32630 32631function useVModels(props, emit, options = {}) { 32632 const ret = {}; 32633 for (const key in props) { 32634 ret[key] = useVModel( 32635 props, 32636 key, 32637 emit, 32638 options 32639 ); 32640 } 32641 return ret; 32642} 32643 32644function useVibrate(options) { 32645 const { 32646 pattern = [], 32647 interval = 0, 32648 navigator = defaultNavigator 32649 } = options || {}; 32650 const isSupported = useSupported(() => typeof navigator !== "undefined" && "vibrate" in navigator); 32651 const patternRef = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(pattern); 32652 let intervalControls; 32653 const vibrate = (pattern2 = patternRef.value) => { 32654 if (isSupported.value) 32655 navigator.vibrate(pattern2); 32656 }; 32657 const stop = () => { 32658 if (isSupported.value) 32659 navigator.vibrate(0); 32660 intervalControls == null ? undefined : intervalControls.pause(); 32661 }; 32662 if (interval > 0) { 32663 intervalControls = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useIntervalFn)( 32664 vibrate, 32665 interval, 32666 { 32667 immediate: false, 32668 immediateCallback: false 32669 } 32670 ); 32671 } 32672 return { 32673 isSupported, 32674 pattern, 32675 intervalControls, 32676 vibrate, 32677 stop 32678 }; 32679} 32680 32681function useVirtualList(list, options) { 32682 const { containerStyle, wrapperProps, scrollTo, calculateRange, currentList, containerRef } = "itemHeight" in options ? useVerticalVirtualList(options, list) : useHorizontalVirtualList(options, list); 32683 return { 32684 list: currentList, 32685 scrollTo, 32686 containerProps: { 32687 ref: containerRef, 32688 onScroll: () => { 32689 calculateRange(); 32690 }, 32691 style: containerStyle 32692 }, 32693 wrapperProps 32694 }; 32695} 32696function useVirtualListResources(list) { 32697 const containerRef = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 32698 const size = useElementSize(containerRef); 32699 const currentList = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)([]); 32700 const source = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(list); 32701 const state = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)({ start: 0, end: 10 }); 32702 return { state, source, currentList, size, containerRef }; 32703} 32704function createGetViewCapacity(state, source, itemSize) { 32705 return (containerSize) => { 32706 if (typeof itemSize === "number") 32707 return Math.ceil(containerSize / itemSize); 32708 const { start = 0 } = state.value; 32709 let sum = 0; 32710 let capacity = 0; 32711 for (let i = start; i < source.value.length; i++) { 32712 const size = itemSize(i); 32713 sum += size; 32714 capacity = i; 32715 if (sum > containerSize) 32716 break; 32717 } 32718 return capacity - start; 32719 }; 32720} 32721function createGetOffset(source, itemSize) { 32722 return (scrollDirection) => { 32723 if (typeof itemSize === "number") 32724 return Math.floor(scrollDirection / itemSize) + 1; 32725 let sum = 0; 32726 let offset = 0; 32727 for (let i = 0; i < source.value.length; i++) { 32728 const size = itemSize(i); 32729 sum += size; 32730 if (sum >= scrollDirection) { 32731 offset = i; 32732 break; 32733 } 32734 } 32735 return offset + 1; 32736 }; 32737} 32738function createCalculateRange(type, overscan, getOffset, getViewCapacity, { containerRef, state, currentList, source }) { 32739 return () => { 32740 const element = containerRef.value; 32741 if (element) { 32742 const offset = getOffset(type === "vertical" ? element.scrollTop : element.scrollLeft); 32743 const viewCapacity = getViewCapacity(type === "vertical" ? element.clientHeight : element.clientWidth); 32744 const from = offset - overscan; 32745 const to = offset + viewCapacity + overscan; 32746 state.value = { 32747 start: from < 0 ? 0 : from, 32748 end: to > source.value.length ? source.value.length : to 32749 }; 32750 currentList.value = source.value.slice(state.value.start, state.value.end).map((ele, index) => ({ 32751 data: ele, 32752 index: index + state.value.start 32753 })); 32754 } 32755 }; 32756} 32757function createGetDistance(itemSize, source) { 32758 return (index) => { 32759 if (typeof itemSize === "number") { 32760 const size2 = index * itemSize; 32761 return size2; 32762 } 32763 const size = source.value.slice(0, index).reduce((sum, _, i) => sum + itemSize(i), 0); 32764 return size; 32765 }; 32766} 32767function useWatchForSizes(size, list, containerRef, calculateRange) { 32768 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)([size.width, size.height, list, containerRef], () => { 32769 calculateRange(); 32770 }); 32771} 32772function createComputedTotalSize(itemSize, source) { 32773 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 32774 if (typeof itemSize === "number") 32775 return source.value.length * itemSize; 32776 return source.value.reduce((sum, _, index) => sum + itemSize(index), 0); 32777 }); 32778} 32779const scrollToDictionaryForElementScrollKey = { 32780 horizontal: "scrollLeft", 32781 vertical: "scrollTop" 32782}; 32783function createScrollTo(type, calculateRange, getDistance, containerRef) { 32784 return (index) => { 32785 if (containerRef.value) { 32786 containerRef.value[scrollToDictionaryForElementScrollKey[type]] = getDistance(index); 32787 calculateRange(); 32788 } 32789 }; 32790} 32791function useHorizontalVirtualList(options, list) { 32792 const resources = useVirtualListResources(list); 32793 const { state, source, currentList, size, containerRef } = resources; 32794 const containerStyle = { overflowX: "auto" }; 32795 const { itemWidth, overscan = 5 } = options; 32796 const getViewCapacity = createGetViewCapacity(state, source, itemWidth); 32797 const getOffset = createGetOffset(source, itemWidth); 32798 const calculateRange = createCalculateRange("horizontal", overscan, getOffset, getViewCapacity, resources); 32799 const getDistanceLeft = createGetDistance(itemWidth, source); 32800 const offsetLeft = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => getDistanceLeft(state.value.start)); 32801 const totalWidth = createComputedTotalSize(itemWidth, source); 32802 useWatchForSizes(size, list, containerRef, calculateRange); 32803 const scrollTo = createScrollTo("horizontal", calculateRange, getDistanceLeft, containerRef); 32804 const wrapperProps = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 32805 return { 32806 style: { 32807 height: "100%", 32808 width: `${totalWidth.value - offsetLeft.value}px`, 32809 marginLeft: `${offsetLeft.value}px`, 32810 display: "flex" 32811 } 32812 }; 32813 }); 32814 return { 32815 scrollTo, 32816 calculateRange, 32817 wrapperProps, 32818 containerStyle, 32819 currentList, 32820 containerRef 32821 }; 32822} 32823function useVerticalVirtualList(options, list) { 32824 const resources = useVirtualListResources(list); 32825 const { state, source, currentList, size, containerRef } = resources; 32826 const containerStyle = { overflowY: "auto" }; 32827 const { itemHeight, overscan = 5 } = options; 32828 const getViewCapacity = createGetViewCapacity(state, source, itemHeight); 32829 const getOffset = createGetOffset(source, itemHeight); 32830 const calculateRange = createCalculateRange("vertical", overscan, getOffset, getViewCapacity, resources); 32831 const getDistanceTop = createGetDistance(itemHeight, source); 32832 const offsetTop = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => getDistanceTop(state.value.start)); 32833 const totalHeight = createComputedTotalSize(itemHeight, source); 32834 useWatchForSizes(size, list, containerRef, calculateRange); 32835 const scrollTo = createScrollTo("vertical", calculateRange, getDistanceTop, containerRef); 32836 const wrapperProps = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => { 32837 return { 32838 style: { 32839 width: "100%", 32840 height: `${totalHeight.value - offsetTop.value}px`, 32841 marginTop: `${offsetTop.value}px` 32842 } 32843 }; 32844 }); 32845 return { 32846 calculateRange, 32847 scrollTo, 32848 containerStyle, 32849 wrapperProps, 32850 currentList, 32851 containerRef 32852 }; 32853} 32854 32855function useWakeLock(options = {}) { 32856 const { 32857 navigator = defaultNavigator, 32858 document = defaultDocument 32859 } = options; 32860 const requestedType = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 32861 const sentinel = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(null); 32862 const documentVisibility = useDocumentVisibility({ document }); 32863 const isSupported = useSupported(() => navigator && "wakeLock" in navigator); 32864 const isActive = (0,vue__WEBPACK_IMPORTED_MODULE_1__.computed)(() => !!sentinel.value && documentVisibility.value === "visible"); 32865 if (isSupported.value) { 32866 useEventListener(sentinel, "release", () => { 32867 var _a, _b; 32868 requestedType.value = (_b = (_a = sentinel.value) == null ? undefined : _a.type) != null ? _b : false; 32869 }, { passive: true }); 32870 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.whenever)( 32871 () => documentVisibility.value === "visible" && (document == null ? undefined : document.visibilityState) === "visible" && requestedType.value, 32872 (type) => { 32873 requestedType.value = false; 32874 forceRequest(type); 32875 } 32876 ); 32877 } 32878 async function forceRequest(type) { 32879 var _a; 32880 await ((_a = sentinel.value) == null ? undefined : _a.release()); 32881 sentinel.value = isSupported.value ? await navigator.wakeLock.request(type) : null; 32882 } 32883 async function request(type) { 32884 if (documentVisibility.value === "visible") 32885 await forceRequest(type); 32886 else 32887 requestedType.value = type; 32888 } 32889 async function release() { 32890 requestedType.value = false; 32891 const s = sentinel.value; 32892 sentinel.value = null; 32893 await (s == null ? undefined : s.release()); 32894 } 32895 return { 32896 sentinel, 32897 isSupported, 32898 isActive, 32899 request, 32900 forceRequest, 32901 release 32902 }; 32903} 32904 32905function useWebNotification(options = {}) { 32906 const { 32907 window = defaultWindow, 32908 requestPermissions: _requestForPermissions = true 32909 } = options; 32910 const defaultWebNotificationOptions = options; 32911 const isSupported = useSupported(() => { 32912 if (!window || !("Notification" in window)) 32913 return false; 32914 if (Notification.permission === "granted") 32915 return true; 32916 try { 32917 const notification2 = new Notification(""); 32918 notification2.onshow = () => { 32919 notification2.close(); 32920 }; 32921 } catch (e) { 32922 if (e.name === "TypeError") 32923 return false; 32924 } 32925 return true; 32926 }); 32927 const permissionGranted = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(isSupported.value && "permission" in Notification && Notification.permission === "granted"); 32928 const notification = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 32929 const ensurePermissions = async () => { 32930 if (!isSupported.value) 32931 return; 32932 if (!permissionGranted.value && Notification.permission !== "denied") { 32933 const result = await Notification.requestPermission(); 32934 if (result === "granted") 32935 permissionGranted.value = true; 32936 } 32937 return permissionGranted.value; 32938 }; 32939 const { on: onClick, trigger: clickTrigger } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 32940 const { on: onShow, trigger: showTrigger } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 32941 const { on: onError, trigger: errorTrigger } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 32942 const { on: onClose, trigger: closeTrigger } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.createEventHook)(); 32943 const show = async (overrides) => { 32944 if (!isSupported.value || !permissionGranted.value) 32945 return; 32946 const options2 = Object.assign({}, defaultWebNotificationOptions, overrides); 32947 notification.value = new Notification(options2.title || "", options2); 32948 notification.value.onclick = clickTrigger; 32949 notification.value.onshow = showTrigger; 32950 notification.value.onerror = errorTrigger; 32951 notification.value.onclose = closeTrigger; 32952 return notification.value; 32953 }; 32954 const close = () => { 32955 if (notification.value) 32956 notification.value.close(); 32957 notification.value = null; 32958 }; 32959 if (_requestForPermissions) 32960 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(ensurePermissions); 32961 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(close); 32962 if (isSupported.value && window) { 32963 const document = window.document; 32964 useEventListener(document, "visibilitychange", (e) => { 32965 e.preventDefault(); 32966 if (document.visibilityState === "visible") { 32967 close(); 32968 } 32969 }); 32970 } 32971 return { 32972 isSupported, 32973 notification, 32974 ensurePermissions, 32975 permissionGranted, 32976 show, 32977 close, 32978 onClick, 32979 onShow, 32980 onError, 32981 onClose 32982 }; 32983} 32984 32985const DEFAULT_PING_MESSAGE = "ping"; 32986function resolveNestedOptions(options) { 32987 if (options === true) 32988 return {}; 32989 return options; 32990} 32991function useWebSocket(url, options = {}) { 32992 const { 32993 onConnected, 32994 onDisconnected, 32995 onError, 32996 onMessage, 32997 immediate = true, 32998 autoConnect = true, 32999 autoClose = true, 33000 protocols = [] 33001 } = options; 33002 const data = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 33003 const status = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)("CLOSED"); 33004 const wsRef = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 33005 const urlRef = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.toRef)(url); 33006 let heartbeatPause; 33007 let heartbeatResume; 33008 let explicitlyClosed = false; 33009 let retried = 0; 33010 let bufferedData = []; 33011 let retryTimeout; 33012 let pongTimeoutWait; 33013 const _sendBuffer = () => { 33014 if (bufferedData.length && wsRef.value && status.value === "OPEN") { 33015 for (const buffer of bufferedData) 33016 wsRef.value.send(buffer); 33017 bufferedData = []; 33018 } 33019 }; 33020 const resetRetry = () => { 33021 if (retryTimeout != null) { 33022 clearTimeout(retryTimeout); 33023 retryTimeout = undefined; 33024 } 33025 }; 33026 const resetHeartbeat = () => { 33027 clearTimeout(pongTimeoutWait); 33028 pongTimeoutWait = undefined; 33029 }; 33030 const close = (code = 1e3, reason) => { 33031 resetRetry(); 33032 if (!_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient && !_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isWorker || !wsRef.value) 33033 return; 33034 explicitlyClosed = true; 33035 resetHeartbeat(); 33036 heartbeatPause == null ? undefined : heartbeatPause(); 33037 wsRef.value.close(code, reason); 33038 wsRef.value = undefined; 33039 }; 33040 const send = (data2, useBuffer = true) => { 33041 if (!wsRef.value || status.value !== "OPEN") { 33042 if (useBuffer) 33043 bufferedData.push(data2); 33044 return false; 33045 } 33046 _sendBuffer(); 33047 wsRef.value.send(data2); 33048 return true; 33049 }; 33050 const _init = () => { 33051 if (explicitlyClosed || typeof urlRef.value === "undefined") 33052 return; 33053 const ws = new WebSocket(urlRef.value, protocols); 33054 wsRef.value = ws; 33055 status.value = "CONNECTING"; 33056 ws.onopen = () => { 33057 status.value = "OPEN"; 33058 retried = 0; 33059 onConnected == null ? undefined : onConnected(ws); 33060 heartbeatResume == null ? undefined : heartbeatResume(); 33061 _sendBuffer(); 33062 }; 33063 ws.onclose = (ev) => { 33064 status.value = "CLOSED"; 33065 onDisconnected == null ? undefined : onDisconnected(ws, ev); 33066 if (!explicitlyClosed && options.autoReconnect && (wsRef.value == null || ws === wsRef.value)) { 33067 const { 33068 retries = -1, 33069 delay = 1e3, 33070 onFailed 33071 } = resolveNestedOptions(options.autoReconnect); 33072 if (typeof retries === "number" && (retries < 0 || retried < retries)) { 33073 retried += 1; 33074 retryTimeout = setTimeout(_init, delay); 33075 } else if (typeof retries === "function" && retries()) { 33076 retryTimeout = setTimeout(_init, delay); 33077 } else { 33078 onFailed == null ? undefined : onFailed(); 33079 } 33080 } 33081 }; 33082 ws.onerror = (e) => { 33083 onError == null ? undefined : onError(ws, e); 33084 }; 33085 ws.onmessage = (e) => { 33086 if (options.heartbeat) { 33087 resetHeartbeat(); 33088 const { 33089 message = DEFAULT_PING_MESSAGE, 33090 responseMessage = message 33091 } = resolveNestedOptions(options.heartbeat); 33092 if (e.data === (0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(responseMessage)) 33093 return; 33094 } 33095 data.value = e.data; 33096 onMessage == null ? undefined : onMessage(ws, e); 33097 }; 33098 }; 33099 if (options.heartbeat) { 33100 const { 33101 message = DEFAULT_PING_MESSAGE, 33102 interval = 1e3, 33103 pongTimeout = 1e3 33104 } = resolveNestedOptions(options.heartbeat); 33105 const { pause, resume } = (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.useIntervalFn)( 33106 () => { 33107 send((0,vue__WEBPACK_IMPORTED_MODULE_1__.toValue)(message), false); 33108 if (pongTimeoutWait != null) 33109 return; 33110 pongTimeoutWait = setTimeout(() => { 33111 close(); 33112 explicitlyClosed = false; 33113 }, pongTimeout); 33114 }, 33115 interval, 33116 { immediate: false } 33117 ); 33118 heartbeatPause = pause; 33119 heartbeatResume = resume; 33120 } 33121 if (autoClose) { 33122 if (_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient) 33123 useEventListener("beforeunload", () => close(), { passive: true }); 33124 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(close); 33125 } 33126 const open = () => { 33127 if (!_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isClient && !_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.isWorker) 33128 return; 33129 close(); 33130 explicitlyClosed = false; 33131 retried = 0; 33132 _init(); 33133 }; 33134 if (immediate) 33135 open(); 33136 if (autoConnect) 33137 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(urlRef, open); 33138 return { 33139 data, 33140 status, 33141 close, 33142 send, 33143 open, 33144 ws: wsRef 33145 }; 33146} 33147 33148function useWebWorker(arg0, workerOptions, options) { 33149 const { 33150 window = defaultWindow 33151 } = options != null ? options : {}; 33152 const data = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(null); 33153 const worker = (0,vue__WEBPACK_IMPORTED_MODULE_1__.shallowRef)(); 33154 const post = (...args) => { 33155 if (!worker.value) 33156 return; 33157 worker.value.postMessage(...args); 33158 }; 33159 const terminate = function terminate2() { 33160 if (!worker.value) 33161 return; 33162 worker.value.terminate(); 33163 }; 33164 if (window) { 33165 if (typeof arg0 === "string") 33166 worker.value = new Worker(arg0, workerOptions); 33167 else if (typeof arg0 === "function") 33168 worker.value = arg0(); 33169 else 33170 worker.value = arg0; 33171 worker.value.onmessage = (e) => { 33172 data.value = e.data; 33173 }; 33174 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(() => { 33175 if (worker.value) 33176 worker.value.terminate(); 33177 }); 33178 } 33179 return { 33180 data, 33181 post, 33182 terminate, 33183 worker 33184 }; 33185} 33186 33187function depsParser(deps, localDeps) { 33188 if (deps.length === 0 && localDeps.length === 0) 33189 return ""; 33190 const depsString = deps.map((dep) => `'${dep}'`).toString(); 33191 const depsFunctionString = localDeps.filter((dep) => typeof dep === "function").map((fn) => { 33192 const str = fn.toString(); 33193 if (str.trim().startsWith("function")) { 33194 return str; 33195 } else { 33196 const name = fn.name; 33197 return `const ${name} = ${str}`; 33198 } 33199 }).join(";"); 33200 const importString = `importScripts(${depsString});`; 33201 return `${depsString.trim() === "" ? "" : importString} ${depsFunctionString}`; 33202} 33203 33204function jobRunner(userFunc) { 33205 return (e) => { 33206 const userFuncArgs = e.data[0]; 33207 return Promise.resolve(userFunc.apply(undefined, userFuncArgs)).then((result) => { 33208 postMessage(["SUCCESS", result]); 33209 }).catch((error) => { 33210 postMessage(["ERROR", error]); 33211 }); 33212 }; 33213} 33214 33215function createWorkerBlobUrl(fn, deps, localDeps) { 33216 const blobCode = `${depsParser(deps, localDeps)}; onmessage=(${jobRunner})(${fn})`; 33217 const blob = new Blob([blobCode], { type: "text/javascript" }); 33218 const url = URL.createObjectURL(blob); 33219 return url; 33220} 33221 33222function useWebWorkerFn(fn, options = {}) { 33223 const { 33224 dependencies = [], 33225 localDependencies = [], 33226 timeout, 33227 window = defaultWindow 33228 } = options; 33229 const worker = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 33230 const workerStatus = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)("PENDING"); 33231 const promise = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)({}); 33232 const timeoutId = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(); 33233 const workerTerminate = (status = "PENDING") => { 33234 if (worker.value && worker.value._url && window) { 33235 worker.value.terminate(); 33236 URL.revokeObjectURL(worker.value._url); 33237 promise.value = {}; 33238 worker.value = undefined; 33239 window.clearTimeout(timeoutId.value); 33240 workerStatus.value = status; 33241 } 33242 }; 33243 workerTerminate(); 33244 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnScopeDispose)(workerTerminate); 33245 const generateWorker = () => { 33246 const blobUrl = createWorkerBlobUrl(fn, dependencies, localDependencies); 33247 const newWorker = new Worker(blobUrl); 33248 newWorker._url = blobUrl; 33249 newWorker.onmessage = (e) => { 33250 const { resolve = () => { 33251 }, reject = () => { 33252 } } = promise.value; 33253 const [status, result] = e.data; 33254 switch (status) { 33255 case "SUCCESS": 33256 resolve(result); 33257 workerTerminate(status); 33258 break; 33259 default: 33260 reject(result); 33261 workerTerminate("ERROR"); 33262 break; 33263 } 33264 }; 33265 newWorker.onerror = (e) => { 33266 const { reject = () => { 33267 } } = promise.value; 33268 e.preventDefault(); 33269 reject(e); 33270 workerTerminate("ERROR"); 33271 }; 33272 if (timeout) { 33273 timeoutId.value = setTimeout( 33274 () => workerTerminate("TIMEOUT_EXPIRED"), 33275 timeout 33276 ); 33277 } 33278 return newWorker; 33279 }; 33280 const callWorker = (...fnArgs) => new Promise((resolve, reject) => { 33281 var _a; 33282 promise.value = { 33283 resolve, 33284 reject 33285 }; 33286 (_a = worker.value) == null ? undefined : _a.postMessage([[...fnArgs]]); 33287 workerStatus.value = "RUNNING"; 33288 }); 33289 const workerFn = (...fnArgs) => { 33290 if (workerStatus.value === "RUNNING") { 33291 console.error( 33292 "[useWebWorkerFn] You can only run one instance of the worker at a time." 33293 ); 33294 return Promise.reject(); 33295 } 33296 worker.value = generateWorker(); 33297 return callWorker(...fnArgs); 33298 }; 33299 return { 33300 workerFn, 33301 workerStatus, 33302 workerTerminate 33303 }; 33304} 33305 33306function useWindowFocus(options = {}) { 33307 const { window = defaultWindow } = options; 33308 if (!window) 33309 return (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(false); 33310 const focused = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(window.document.hasFocus()); 33311 const listenerOptions = { passive: true }; 33312 useEventListener(window, "blur", () => { 33313 focused.value = false; 33314 }, listenerOptions); 33315 useEventListener(window, "focus", () => { 33316 focused.value = true; 33317 }, listenerOptions); 33318 return focused; 33319} 33320 33321function useWindowScroll(options = {}) { 33322 const { window = defaultWindow, ...rest } = options; 33323 return useScroll(window, rest); 33324} 33325 33326function useWindowSize(options = {}) { 33327 const { 33328 window = defaultWindow, 33329 initialWidth = Number.POSITIVE_INFINITY, 33330 initialHeight = Number.POSITIVE_INFINITY, 33331 listenOrientation = true, 33332 includeScrollbar = true, 33333 type = "inner" 33334 } = options; 33335 const width = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialWidth); 33336 const height = (0,vue__WEBPACK_IMPORTED_MODULE_1__.ref)(initialHeight); 33337 const update = () => { 33338 if (window) { 33339 if (type === "outer") { 33340 width.value = window.outerWidth; 33341 height.value = window.outerHeight; 33342 } else if (type === "visual" && window.visualViewport) { 33343 const { width: visualViewportWidth, height: visualViewportHeight, scale } = window.visualViewport; 33344 width.value = Math.round(visualViewportWidth * scale); 33345 height.value = Math.round(visualViewportHeight * scale); 33346 } else if (includeScrollbar) { 33347 width.value = window.innerWidth; 33348 height.value = window.innerHeight; 33349 } else { 33350 width.value = window.document.documentElement.clientWidth; 33351 height.value = window.document.documentElement.clientHeight; 33352 } 33353 } 33354 }; 33355 update(); 33356 (0,_vueuse_shared__WEBPACK_IMPORTED_MODULE_0__.tryOnMounted)(update); 33357 const listenerOptions = { passive: true }; 33358 useEventListener("resize", update, listenerOptions); 33359 if (window && type === "visual" && window.visualViewport) { 33360 useEventListener(window.visualViewport, "resize", update, listenerOptions); 33361 } 33362 if (listenOrientation) { 33363 const matches = useMediaQuery("(orientation: portrait)"); 33364 (0,vue__WEBPACK_IMPORTED_MODULE_1__.watch)(matches, () => update()); 33365 } 33366 return { width, height }; 33367} 33368 33369 33370 33371 33372/***/ }), 33373
vendor: 57,248 bytes, lines 33374-35095
33374/***/ "./node_modules/@vueuse/shared/index.mjs": 33375/*!***********************************************!*\ 33376 !*** ./node_modules/@vueuse/shared/index.mjs ***! 33377 \***********************************************/ 33378/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 33379 33380"use strict"; 33381__webpack_require__.r(__webpack_exports__); 33382/* harmony export */ __webpack_require__.d(__webpack_exports__, { 33383/* harmony export */ assert: () => (/* binding */ assert), 33384/* harmony export */ autoResetRef: () => (/* binding */ refAutoReset), 33385/* harmony export */ bypassFilter: () => (/* binding */ bypassFilter), 33386/* harmony export */ camelize: () => (/* binding */ camelize), 33387/* harmony export */ clamp: () => (/* binding */ clamp), 33388/* harmony export */ computedEager: () => (/* binding */ computedEager), 33389/* harmony export */ computedWithControl: () => (/* binding */ computedWithControl), 33390/* harmony export */ containsProp: () => (/* binding */ containsProp), 33391/* harmony export */ controlledComputed: () => (/* binding */ computedWithControl), 33392/* harmony export */ controlledRef: () => (/* binding */ controlledRef), 33393/* harmony export */ createEventHook: () => (/* binding */ createEventHook), 33394/* harmony export */ createFilterWrapper: () => (/* binding */ createFilterWrapper), 33395/* harmony export */ createGlobalState: () => (/* binding */ createGlobalState), 33396/* harmony export */ createInjectionState: () => (/* binding */ createInjectionState), 33397/* harmony export */ createReactiveFn: () => (/* binding */ reactify), 33398/* harmony export */ createSharedComposable: () => (/* binding */ createSharedComposable), 33399/* harmony export */ createSingletonPromise: () => (/* binding */ createSingletonPromise), 33400/* harmony export */ debounceFilter: () => (/* binding */ debounceFilter), 33401/* harmony export */ debouncedRef: () => (/* binding */ refDebounced), 33402/* harmony export */ debouncedWatch: () => (/* binding */ watchDebounced), 33403/* harmony export */ eagerComputed: () => (/* binding */ computedEager), 33404/* harmony export */ extendRef: () => (/* binding */ extendRef), 33405/* harmony export */ formatDate: () => (/* binding */ formatDate), 33406/* harmony export */ get: () => (/* binding */ get), 33407/* harmony export */ getLifeCycleTarget: () => (/* binding */ getLifeCycleTarget), 33408/* harmony export */ hasOwn: () => (/* binding */ hasOwn), 33409/* harmony export */ hyphenate: () => (/* binding */ hyphenate), 33410/* harmony export */ identity: () => (/* binding */ identity), 33411/* harmony export */ ignorableWatch: () => (/* binding */ watchIgnorable), 33412/* harmony export */ increaseWithUnit: () => (/* binding */ increaseWithUnit), 33413/* harmony export */ injectLocal: () => (/* binding */ injectLocal), 33414/* harmony export */ invoke: () => (/* binding */ invoke), 33415/* harmony export */ isClient: () => (/* binding */ isClient), 33416/* harmony export */ isDef: () => (/* binding */ isDef), 33417/* harmony export */ isDefined: () => (/* binding */ isDefined), 33418/* harmony export */ isIOS: () => (/* binding */ isIOS), 33419/* harmony export */ isObject: () => (/* binding */ isObject), 33420/* harmony export */ isWorker: () => (/* binding */ isWorker), 33421/* harmony export */ makeDestructurable: () => (/* binding */ makeDestructurable), 33422/* harmony export */ noop: () => (/* binding */ noop), 33423/* harmony export */ normalizeDate: () => (/* binding */ normalizeDate), 33424/* harmony export */ notNullish: () => (/* binding */ notNullish), 33425/* harmony export */ now: () => (/* binding */ now), 33426/* harmony export */ objectEntries: () => (/* binding */ objectEntries), 33427/* harmony export */ objectOmit: () => (/* binding */ objectOmit), 33428/* harmony export */ objectPick: () => (/* binding */ objectPick), 33429/* harmony export */ pausableFilter: () => (/* binding */ pausableFilter), 33430/* harmony export */ pausableWatch: () => (/* binding */ watchPausable), 33431/* harmony export */ promiseTimeout: () => (/* binding */ promiseTimeout), 33432/* harmony export */ provideLocal: () => (/* binding */ provideLocal), 33433/* harmony export */ pxValue: () => (/* binding */ pxValue), 33434/* harmony export */ rand: () => (/* binding */ rand), 33435/* harmony export */ reactify: () => (/* binding */ reactify), 33436/* harmony export */ reactifyObject: () => (/* binding */ reactifyObject), 33437/* harmony export */ reactiveComputed: () => (/* binding */ reactiveComputed), 33438/* harmony export */ reactiveOmit: () => (/* binding */ reactiveOmit), 33439/* harmony export */ reactivePick: () => (/* binding */ reactivePick), 33440/* harmony export */ refAutoReset: () => (/* binding */ refAutoReset), 33441/* harmony export */ refDebounced: () => (/* binding */ refDebounced), 33442/* harmony export */ refDefault: () => (/* binding */ refDefault), 33443/* harmony export */ refThrottled: () => (/* binding */ refThrottled), 33444/* harmony export */ refWithControl: () => (/* binding */ refWithControl), 33445/* harmony export */ resolveRef: () => (/* binding */ resolveRef), 33446/* harmony export */ resolveUnref: () => (/* binding */ resolveUnref), 33447/* harmony export */ set: () => (/* binding */ set), 33448/* harmony export */ syncRef: () => (/* binding */ syncRef), 33449/* harmony export */ syncRefs: () => (/* binding */ syncRefs), 33450/* harmony export */ throttleFilter: () => (/* binding */ throttleFilter), 33451/* harmony export */ throttledRef: () => (/* binding */ refThrottled), 33452/* harmony export */ throttledWatch: () => (/* binding */ watchThrottled), 33453/* harmony export */ timestamp: () => (/* binding */ timestamp), 33454/* harmony export */ toArray: () => (/* binding */ toArray), 33455/* harmony export */ toReactive: () => (/* binding */ toReactive), 33456/* harmony export */ toRef: () => (/* binding */ toRef), 33457/* harmony export */ toRefs: () => (/* binding */ toRefs), 33458/* harmony export */ toValue: () => (/* binding */ toValue), 33459/* harmony export */ tryOnBeforeMount: () => (/* binding */ tryOnBeforeMount), 33460/* harmony export */ tryOnBeforeUnmount: () => (/* binding */ tryOnBeforeUnmount), 33461/* harmony export */ tryOnMounted: () => (/* binding */ tryOnMounted), 33462/* harmony export */ tryOnScopeDispose: () => (/* binding */ tryOnScopeDispose), 33463/* harmony export */ tryOnUnmounted: () => (/* binding */ tryOnUnmounted), 33464/* harmony export */ until: () => (/* binding */ until), 33465/* harmony export */ useArrayDifference: () => (/* binding */ useArrayDifference), 33466/* harmony export */ useArrayEvery: () => (/* binding */ useArrayEvery), 33467/* harmony export */ useArrayFilter: () => (/* binding */ useArrayFilter), 33468/* harmony export */ useArrayFind: () => (/* binding */ useArrayFind), 33469/* harmony export */ useArrayFindIndex: () => (/* binding */ useArrayFindIndex), 33470/* harmony export */ useArrayFindLast: () => (/* binding */ useArrayFindLast), 33471/* harmony export */ useArrayIncludes: () => (/* binding */ useArrayIncludes), 33472/* harmony export */ useArrayJoin: () => (/* binding */ useArrayJoin), 33473/* harmony export */ useArrayMap: () => (/* binding */ useArrayMap), 33474/* harmony export */ useArrayReduce: () => (/* binding */ useArrayReduce), 33475/* harmony export */ useArraySome: () => (/* binding */ useArraySome), 33476/* harmony export */ useArrayUnique: () => (/* binding */ useArrayUnique), 33477/* harmony export */ useCounter: () => (/* binding */ useCounter), 33478/* harmony export */ useDateFormat: () => (/* binding */ useDateFormat), 33479/* harmony export */ useDebounce: () => (/* binding */ refDebounced), 33480/* harmony export */ useDebounceFn: () => (/* binding */ useDebounceFn), 33481/* harmony export */ useInterval: () => (/* binding */ useInterval), 33482/* harmony export */ useIntervalFn: () => (/* binding */ useIntervalFn), 33483/* harmony export */ useLastChanged: () => (/* binding */ useLastChanged), 33484/* harmony export */ useThrottle: () => (/* binding */ refThrottled), 33485/* harmony export */ useThrottleFn: () => (/* binding */ useThrottleFn), 33486/* harmony export */ useTimeout: () => (/* binding */ useTimeout), 33487/* harmony export */ useTimeoutFn: () => (/* binding */ useTimeoutFn), 33488/* harmony export */ useToNumber: () => (/* binding */ useToNumber), 33489/* harmony export */ useToString: () => (/* binding */ useToString), 33490/* harmony export */ useToggle: () => (/* binding */ useToggle), 33491/* harmony export */ watchArray: () => (/* binding */ watchArray), 33492/* harmony export */ watchAtMost: () => (/* binding */ watchAtMost), 33493/* harmony export */ watchDebounced: () => (/* binding */ watchDebounced), 33494/* harmony export */ watchDeep: () => (/* binding */ watchDeep), 33495/* harmony export */ watchIgnorable: () => (/* binding */ watchIgnorable), 33496/* harmony export */ watchImmediate: () => (/* binding */ watchImmediate), 33497/* harmony export */ watchOnce: () => (/* binding */ watchOnce), 33498/* harmony export */ watchPausable: () => (/* binding */ watchPausable), 33499/* harmony export */ watchThrottled: () => (/* binding */ watchThrottled), 33500/* harmony export */ watchTriggerable: () => (/* binding */ watchTriggerable), 33501/* harmony export */ watchWithFilter: () => (/* binding */ watchWithFilter), 33502/* harmony export */ whenever: () => (/* binding */ whenever) 33503/* harmony export */ }); 33504/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.esm-bundler.js"); 33505 33506 33507function computedEager(fn, options) { 33508 var _a; 33509 const result = (0,vue__WEBPACK_IMPORTED_MODULE_0__.shallowRef)(); 33510 (0,vue__WEBPACK_IMPORTED_MODULE_0__.watchEffect)(() => { 33511 result.value = fn(); 33512 }, { 33513 ...options, 33514 flush: (_a = options == null ? undefined : options.flush) != null ? _a : "sync" 33515 }); 33516 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.readonly)(result); 33517} 33518 33519function computedWithControl(source, fn) { 33520 let v = undefined; 33521 let track; 33522 let trigger; 33523 const dirty = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(true); 33524 const update = () => { 33525 dirty.value = true; 33526 trigger(); 33527 }; 33528 (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(source, update, { flush: "sync" }); 33529 const get = typeof fn === "function" ? fn : fn.get; 33530 const set = typeof fn === "function" ? undefined : fn.set; 33531 const result = (0,vue__WEBPACK_IMPORTED_MODULE_0__.customRef)((_track, _trigger) => { 33532 track = _track; 33533 trigger = _trigger; 33534 return { 33535 get() { 33536 if (dirty.value) { 33537 v = get(v); 33538 dirty.value = false; 33539 } 33540 track(); 33541 return v; 33542 }, 33543 set(v2) { 33544 set == null ? undefined : set(v2); 33545 } 33546 }; 33547 }); 33548 if (Object.isExtensible(result)) 33549 result.trigger = update; 33550 return result; 33551} 33552 33553function tryOnScopeDispose(fn) { 33554 if ((0,vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope)()) { 33555 (0,vue__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose)(fn); 33556 return true; 33557 } 33558 return false; 33559} 33560 33561function createEventHook() { 33562 const fns = /* @__PURE__ */ new Set(); 33563 const off = (fn) => { 33564 fns.delete(fn); 33565 }; 33566 const clear = () => { 33567 fns.clear(); 33568 }; 33569 const on = (fn) => { 33570 fns.add(fn); 33571 const offFn = () => off(fn); 33572 tryOnScopeDispose(offFn); 33573 return { 33574 off: offFn 33575 }; 33576 }; 33577 const trigger = (...args) => { 33578 return Promise.all(Array.from(fns).map((fn) => fn(...args))); 33579 }; 33580 return { 33581 on, 33582 off, 33583 trigger, 33584 clear 33585 }; 33586} 33587 33588function createGlobalState(stateFactory) { 33589 let initialized = false; 33590 let state; 33591 const scope = (0,vue__WEBPACK_IMPORTED_MODULE_0__.effectScope)(true); 33592 return (...args) => { 33593 if (!initialized) { 33594 state = scope.run(() => stateFactory(...args)); 33595 initialized = true; 33596 } 33597 return state; 33598 }; 33599} 33600 33601const localProvidedStateMap = /* @__PURE__ */ new WeakMap(); 33602 33603const injectLocal = (...args) => { 33604 var _a; 33605 const key = args[0]; 33606 const instance = (_a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)()) == null ? undefined : _a.proxy; 33607 if (instance == null && !(0,vue__WEBPACK_IMPORTED_MODULE_0__.hasInjectionContext)()) 33608 throw new Error("injectLocal must be called in setup"); 33609 if (instance && localProvidedStateMap.has(instance) && key in localProvidedStateMap.get(instance)) 33610 return localProvidedStateMap.get(instance)[key]; 33611 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.inject)(...args); 33612}; 33613 33614const provideLocal = (key, value) => { 33615 var _a; 33616 const instance = (_a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)()) == null ? undefined : _a.proxy; 33617 if (instance == null) 33618 throw new Error("provideLocal must be called in setup"); 33619 if (!localProvidedStateMap.has(instance)) 33620 localProvidedStateMap.set(instance, /* @__PURE__ */ Object.create(null)); 33621 const localProvidedState = localProvidedStateMap.get(instance); 33622 localProvidedState[key] = value; 33623 (0,vue__WEBPACK_IMPORTED_MODULE_0__.provide)(key, value); 33624}; 33625 33626function createInjectionState(composable, options) { 33627 const key = (options == null ? undefined : options.injectionKey) || Symbol(composable.name || "InjectionState"); 33628 const defaultValue = options == null ? undefined : options.defaultValue; 33629 const useProvidingState = (...args) => { 33630 const state = composable(...args); 33631 provideLocal(key, state); 33632 return state; 33633 }; 33634 const useInjectedState = () => injectLocal(key, defaultValue); 33635 return [useProvidingState, useInjectedState]; 33636} 33637 33638function createSharedComposable(composable) { 33639 let subscribers = 0; 33640 let state; 33641 let scope; 33642 const dispose = () => { 33643 subscribers -= 1; 33644 if (scope && subscribers <= 0) { 33645 scope.stop(); 33646 state = undefined; 33647 scope = undefined; 33648 } 33649 }; 33650 return (...args) => { 33651 subscribers += 1; 33652 if (!scope) { 33653 scope = (0,vue__WEBPACK_IMPORTED_MODULE_0__.effectScope)(true); 33654 state = scope.run(() => composable(...args)); 33655 } 33656 tryOnScopeDispose(dispose); 33657 return state; 33658 }; 33659} 33660 33661function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) { 33662 for (const [key, value] of Object.entries(extend)) { 33663 if (key === "value") 33664 continue; 33665 if ((0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(value) && unwrap) { 33666 Object.defineProperty(ref, key, { 33667 get() { 33668 return value.value; 33669 }, 33670 set(v) { 33671 value.value = v; 33672 }, 33673 enumerable 33674 }); 33675 } else { 33676 Object.defineProperty(ref, key, { value, enumerable }); 33677 } 33678 } 33679 return ref; 33680} 33681 33682function get(obj, key) { 33683 if (key == null) 33684 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(obj); 33685 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(obj)[key]; 33686} 33687 33688function isDefined(v) { 33689 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v) != null; 33690} 33691 33692function makeDestructurable(obj, arr) { 33693 if (typeof Symbol !== "undefined") { 33694 const clone = { ...obj }; 33695 Object.defineProperty(clone, Symbol.iterator, { 33696 enumerable: false, 33697 value() { 33698 let index = 0; 33699 return { 33700 next: () => ({ 33701 value: arr[index++], 33702 done: index > arr.length 33703 }) 33704 }; 33705 } 33706 }); 33707 return clone; 33708 } else { 33709 return Object.assign([...arr], obj); 33710 } 33711} 33712 33713function reactify(fn, options) { 33714 const unrefFn = (options == null ? undefined : options.computedGetter) === false ? vue__WEBPACK_IMPORTED_MODULE_0__.unref : vue__WEBPACK_IMPORTED_MODULE_0__.toValue; 33715 return function(...args) { 33716 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => fn.apply(this, args.map((i) => unrefFn(i)))); 33717 }; 33718} 33719 33720function reactifyObject(obj, optionsOrKeys = {}) { 33721 let keys = []; 33722 let options; 33723 if (Array.isArray(optionsOrKeys)) { 33724 keys = optionsOrKeys; 33725 } else { 33726 options = optionsOrKeys; 33727 const { includeOwnProperties = true } = optionsOrKeys; 33728 keys.push(...Object.keys(obj)); 33729 if (includeOwnProperties) 33730 keys.push(...Object.getOwnPropertyNames(obj)); 33731 } 33732 return Object.fromEntries( 33733 keys.map((key) => { 33734 const value = obj[key]; 33735 return [ 33736 key, 33737 typeof value === "function" ? reactify(value.bind(obj), options) : value 33738 ]; 33739 }) 33740 ); 33741} 33742 33743function toReactive(objectRef) { 33744 if (!(0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(objectRef)) 33745 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.reactive)(objectRef); 33746 const proxy = new Proxy({}, { 33747 get(_, p, receiver) { 33748 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(Reflect.get(objectRef.value, p, receiver)); 33749 }, 33750 set(_, p, value) { 33751 if ((0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(objectRef.value[p]) && !(0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(value)) 33752 objectRef.value[p].value = value; 33753 else 33754 objectRef.value[p] = value; 33755 return true; 33756 }, 33757 deleteProperty(_, p) { 33758 return Reflect.deleteProperty(objectRef.value, p); 33759 }, 33760 has(_, p) { 33761 return Reflect.has(objectRef.value, p); 33762 }, 33763 ownKeys() { 33764 return Object.keys(objectRef.value); 33765 }, 33766 getOwnPropertyDescriptor() { 33767 return { 33768 enumerable: true, 33769 configurable: true 33770 }; 33771 } 33772 }); 33773 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.reactive)(proxy); 33774} 33775 33776function reactiveComputed(fn) { 33777 return toReactive((0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(fn)); 33778} 33779 33780function reactiveOmit(obj, ...keys) { 33781 const flatKeys = keys.flat(); 33782 const predicate = flatKeys[0]; 33783 return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries((0,vue__WEBPACK_IMPORTED_MODULE_0__.toRefs)(obj)).filter(([k, v]) => !predicate((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(v), k))) : Object.fromEntries(Object.entries((0,vue__WEBPACK_IMPORTED_MODULE_0__.toRefs)(obj)).filter((e) => !flatKeys.includes(e[0])))); 33784} 33785 33786const isClient = typeof window !== "undefined" && typeof document !== "undefined"; 33787const isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope; 33788const isDef = (val) => typeof val !== "undefined"; 33789const notNullish = (val) => val != null; 33790const assert = (condition, ...infos) => { 33791 if (!condition) 33792 console.warn(...infos); 33793}; 33794const toString = Object.prototype.toString; 33795const isObject = (val) => toString.call(val) === "[object Object]"; 33796const now = () => Date.now(); 33797const timestamp = () => +Date.now(); 33798const clamp = (n, min, max) => Math.min(max, Math.max(min, n)); 33799const noop = () => { 33800}; 33801const rand = (min, max) => { 33802 min = Math.ceil(min); 33803 max = Math.floor(max); 33804 return Math.floor(Math.random() * (max - min + 1)) + min; 33805}; 33806const hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key); 33807const isIOS = /* @__PURE__ */ getIsIOS(); 33808function getIsIOS() { 33809 var _a, _b; 33810 return isClient && ((_a = window == null ? undefined : window.navigator) == null ? undefined : _a.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? undefined : window.navigator) == null ? undefined : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? undefined : window.navigator.userAgent)); 33811} 33812 33813function createFilterWrapper(filter, fn) { 33814 function wrapper(...args) { 33815 return new Promise((resolve, reject) => { 33816 Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject); 33817 }); 33818 } 33819 return wrapper; 33820} 33821const bypassFilter = (invoke) => { 33822 return invoke(); 33823}; 33824function debounceFilter(ms, options = {}) { 33825 let timer; 33826 let maxTimer; 33827 let lastRejector = noop; 33828 const _clearTimeout = (timer2) => { 33829 clearTimeout(timer2); 33830 lastRejector(); 33831 lastRejector = noop; 33832 }; 33833 let lastInvoker; 33834 const filter = (invoke) => { 33835 const duration = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(ms); 33836 const maxDuration = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(options.maxWait); 33837 if (timer) 33838 _clearTimeout(timer); 33839 if (duration <= 0 || maxDuration !== undefined && maxDuration <= 0) { 33840 if (maxTimer) { 33841 _clearTimeout(maxTimer); 33842 maxTimer = null; 33843 } 33844 return Promise.resolve(invoke()); 33845 } 33846 return new Promise((resolve, reject) => { 33847 lastRejector = options.rejectOnCancel ? reject : resolve; 33848 lastInvoker = invoke; 33849 if (maxDuration && !maxTimer) { 33850 maxTimer = setTimeout(() => { 33851 if (timer) 33852 _clearTimeout(timer); 33853 maxTimer = null; 33854 resolve(lastInvoker()); 33855 }, maxDuration); 33856 } 33857 timer = setTimeout(() => { 33858 if (maxTimer) 33859 _clearTimeout(maxTimer); 33860 maxTimer = null; 33861 resolve(invoke()); 33862 }, duration); 33863 }); 33864 }; 33865 return filter; 33866} 33867function throttleFilter(...args) { 33868 let lastExec = 0; 33869 let timer; 33870 let isLeading = true; 33871 let lastRejector = noop; 33872 let lastValue; 33873 let ms; 33874 let trailing; 33875 let leading; 33876 let rejectOnCancel; 33877 if (!(0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(args[0]) && typeof args[0] === "object") 33878 ({ delay: ms, trailing = true, leading = true, rejectOnCancel = false } = args[0]); 33879 else 33880 [ms, trailing = true, leading = true, rejectOnCancel = false] = args; 33881 const clear = () => { 33882 if (timer) { 33883 clearTimeout(timer); 33884 timer = undefined; 33885 lastRejector(); 33886 lastRejector = noop; 33887 } 33888 }; 33889 const filter = (_invoke) => { 33890 const duration = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(ms); 33891 const elapsed = Date.now() - lastExec; 33892 const invoke = () => { 33893 return lastValue = _invoke(); 33894 }; 33895 clear(); 33896 if (duration <= 0) { 33897 lastExec = Date.now(); 33898 return invoke(); 33899 } 33900 if (elapsed > duration && (leading || !isLeading)) { 33901 lastExec = Date.now(); 33902 invoke(); 33903 } else if (trailing) { 33904 lastValue = new Promise((resolve, reject) => { 33905 lastRejector = rejectOnCancel ? reject : resolve; 33906 timer = setTimeout(() => { 33907 lastExec = Date.now(); 33908 isLeading = true; 33909 resolve(invoke()); 33910 clear(); 33911 }, Math.max(0, duration - elapsed)); 33912 }); 33913 } 33914 if (!leading && !timer) 33915 timer = setTimeout(() => isLeading = true, duration); 33916 isLeading = false; 33917 return lastValue; 33918 }; 33919 return filter; 33920} 33921function pausableFilter(extendFilter = bypassFilter) { 33922 const isActive = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(true); 33923 function pause() { 33924 isActive.value = false; 33925 } 33926 function resume() { 33927 isActive.value = true; 33928 } 33929 const eventFilter = (...args) => { 33930 if (isActive.value) 33931 extendFilter(...args); 33932 }; 33933 return { isActive: (0,vue__WEBPACK_IMPORTED_MODULE_0__.readonly)(isActive), pause, resume, eventFilter }; 33934} 33935 33936function cacheStringFunction(fn) { 33937 const cache = /* @__PURE__ */ Object.create(null); 33938 return (str) => { 33939 const hit = cache[str]; 33940 return hit || (cache[str] = fn(str)); 33941 }; 33942} 33943const hyphenateRE = /\B([A-Z])/g; 33944const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase()); 33945const camelizeRE = /-(\w)/g; 33946const camelize = cacheStringFunction((str) => { 33947 return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : ""); 33948}); 33949 33950function promiseTimeout(ms, throwOnTimeout = false, reason = "Timeout") { 33951 return new Promise((resolve, reject) => { 33952 if (throwOnTimeout) 33953 setTimeout(() => reject(reason), ms); 33954 else 33955 setTimeout(resolve, ms); 33956 }); 33957} 33958function identity(arg) { 33959 return arg; 33960} 33961function createSingletonPromise(fn) { 33962 let _promise; 33963 function wrapper() { 33964 if (!_promise) 33965 _promise = fn(); 33966 return _promise; 33967 } 33968 wrapper.reset = async () => { 33969 const _prev = _promise; 33970 _promise = undefined; 33971 if (_prev) 33972 await _prev; 33973 }; 33974 return wrapper; 33975} 33976function invoke(fn) { 33977 return fn(); 33978} 33979function containsProp(obj, ...props) { 33980 return props.some((k) => k in obj); 33981} 33982function increaseWithUnit(target, delta) { 33983 var _a; 33984 if (typeof target === "number") 33985 return target + delta; 33986 const value = ((_a = target.match(/^-?\d+\.?\d*/)) == null ? undefined : _a[0]) || ""; 33987 const unit = target.slice(value.length); 33988 const result = Number.parseFloat(value) + delta; 33989 if (Number.isNaN(result)) 33990 return target; 33991 return result + unit; 33992} 33993function pxValue(px) { 33994 return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px); 33995} 33996function objectPick(obj, keys, omitUndefined = false) { 33997 return keys.reduce((n, k) => { 33998 if (k in obj) { 33999 if (!omitUndefined || obj[k] !== undefined) 34000 n[k] = obj[k]; 34001 } 34002 return n; 34003 }, {}); 34004} 34005function objectOmit(obj, keys, omitUndefined = false) { 34006 return Object.fromEntries(Object.entries(obj).filter(([key, value]) => { 34007 return (!omitUndefined || value !== undefined) && !keys.includes(key); 34008 })); 34009} 34010function objectEntries(obj) { 34011 return Object.entries(obj); 34012} 34013function getLifeCycleTarget(target) { 34014 return target || (0,vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)(); 34015} 34016function toArray(value) { 34017 return Array.isArray(value) ? value : [value]; 34018} 34019 34020function toRef(...args) { 34021 if (args.length !== 1) 34022 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.toRef)(...args); 34023 const r = args[0]; 34024 return typeof r === "function" ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.readonly)((0,vue__WEBPACK_IMPORTED_MODULE_0__.customRef)(() => ({ get: r, set: noop }))) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(r); 34025} 34026const resolveRef = toRef; 34027 34028function reactivePick(obj, ...keys) { 34029 const flatKeys = keys.flat(); 34030 const predicate = flatKeys[0]; 34031 return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries((0,vue__WEBPACK_IMPORTED_MODULE_0__.toRefs)(obj)).filter(([k, v]) => predicate((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)]))); 34032} 34033 34034function refAutoReset(defaultValue, afterMs = 1e4) { 34035 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.customRef)((track, trigger) => { 34036 let value = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(defaultValue); 34037 let timer; 34038 const resetAfter = () => setTimeout(() => { 34039 value = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(defaultValue); 34040 trigger(); 34041 }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(afterMs)); 34042 tryOnScopeDispose(() => { 34043 clearTimeout(timer); 34044 }); 34045 return { 34046 get() { 34047 track(); 34048 return value; 34049 }, 34050 set(newValue) { 34051 value = newValue; 34052 trigger(); 34053 clearTimeout(timer); 34054 timer = resetAfter(); 34055 } 34056 }; 34057 }); 34058} 34059 34060function useDebounceFn(fn, ms = 200, options = {}) { 34061 return createFilterWrapper( 34062 debounceFilter(ms, options), 34063 fn 34064 ); 34065} 34066 34067function refDebounced(value, ms = 200, options = {}) { 34068 const debounced = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(value.value); 34069 const updater = useDebounceFn(() => { 34070 debounced.value = value.value; 34071 }, ms, options); 34072 (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(value, () => updater()); 34073 return debounced; 34074} 34075 34076function refDefault(source, defaultValue) { 34077 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({ 34078 get() { 34079 var _a; 34080 return (_a = source.value) != null ? _a : defaultValue; 34081 }, 34082 set(value) { 34083 source.value = value; 34084 } 34085 }); 34086} 34087 34088function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) { 34089 return createFilterWrapper( 34090 throttleFilter(ms, trailing, leading, rejectOnCancel), 34091 fn 34092 ); 34093} 34094 34095function refThrottled(value, delay = 200, trailing = true, leading = true) { 34096 if (delay <= 0) 34097 return value; 34098 const throttled = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(value.value); 34099 const updater = useThrottleFn(() => { 34100 throttled.value = value.value; 34101 }, delay, trailing, leading); 34102 (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(value, () => updater()); 34103 return throttled; 34104} 34105 34106function refWithControl(initial, options = {}) { 34107 let source = initial; 34108 let track; 34109 let trigger; 34110 const ref = (0,vue__WEBPACK_IMPORTED_MODULE_0__.customRef)((_track, _trigger) => { 34111 track = _track; 34112 trigger = _trigger; 34113 return { 34114 get() { 34115 return get(); 34116 }, 34117 set(v) { 34118 set(v); 34119 } 34120 }; 34121 }); 34122 function get(tracking = true) { 34123 if (tracking) 34124 track(); 34125 return source; 34126 } 34127 function set(value, triggering = true) { 34128 var _a, _b; 34129 if (value === source) 34130 return; 34131 const old = source; 34132 if (((_a = options.onBeforeChange) == null ? undefined : _a.call(options, value, old)) === false) 34133 return; 34134 source = value; 34135 (_b = options.onChanged) == null ? undefined : _b.call(options, value, old); 34136 if (triggering) 34137 trigger(); 34138 } 34139 const untrackedGet = () => get(false); 34140 const silentSet = (v) => set(v, false); 34141 const peek = () => get(false); 34142 const lay = (v) => set(v, false); 34143 return extendRef( 34144 ref, 34145 { 34146 get, 34147 set, 34148 untrackedGet, 34149 silentSet, 34150 peek, 34151 lay 34152 }, 34153 { enumerable: true } 34154 ); 34155} 34156const controlledRef = refWithControl; 34157 34158function set(...args) { 34159 if (args.length === 2) { 34160 const [ref, value] = args; 34161 ref.value = value; 34162 } 34163 if (args.length === 3) { 34164 const [target, key, value] = args; 34165 target[key] = value; 34166 } 34167} 34168 34169function watchWithFilter(source, cb, options = {}) { 34170 const { 34171 eventFilter = bypassFilter, 34172 ...watchOptions 34173 } = options; 34174 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 34175 source, 34176 createFilterWrapper( 34177 eventFilter, 34178 cb 34179 ), 34180 watchOptions 34181 ); 34182} 34183 34184function watchPausable(source, cb, options = {}) { 34185 const { 34186 eventFilter: filter, 34187 ...watchOptions 34188 } = options; 34189 const { eventFilter, pause, resume, isActive } = pausableFilter(filter); 34190 const stop = watchWithFilter( 34191 source, 34192 cb, 34193 { 34194 ...watchOptions, 34195 eventFilter 34196 } 34197 ); 34198 return { stop, pause, resume, isActive }; 34199} 34200 34201function syncRef(left, right, ...[options]) { 34202 const { 34203 flush = "sync", 34204 deep = false, 34205 immediate = true, 34206 direction = "both", 34207 transform = {} 34208 } = options || {}; 34209 const watchers = []; 34210 const transformLTR = "ltr" in transform && transform.ltr || ((v) => v); 34211 const transformRTL = "rtl" in transform && transform.rtl || ((v) => v); 34212 if (direction === "both" || direction === "ltr") { 34213 watchers.push(watchPausable( 34214 left, 34215 (newValue) => { 34216 watchers.forEach((w) => w.pause()); 34217 right.value = transformLTR(newValue); 34218 watchers.forEach((w) => w.resume()); 34219 }, 34220 { flush, deep, immediate } 34221 )); 34222 } 34223 if (direction === "both" || direction === "rtl") { 34224 watchers.push(watchPausable( 34225 right, 34226 (newValue) => { 34227 watchers.forEach((w) => w.pause()); 34228 left.value = transformRTL(newValue); 34229 watchers.forEach((w) => w.resume()); 34230 }, 34231 { flush, deep, immediate } 34232 )); 34233 } 34234 const stop = () => { 34235 watchers.forEach((w) => w.stop()); 34236 }; 34237 return stop; 34238} 34239 34240function syncRefs(source, targets, options = {}) { 34241 const { 34242 flush = "sync", 34243 deep = false, 34244 immediate = true 34245 } = options; 34246 targets = toArray(targets); 34247 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 34248 source, 34249 (newValue) => targets.forEach((target) => target.value = newValue), 34250 { flush, deep, immediate } 34251 ); 34252} 34253 34254function toRefs(objectRef, options = {}) { 34255 if (!(0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(objectRef)) 34256 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.toRefs)(objectRef); 34257 const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {}; 34258 for (const key in objectRef.value) { 34259 result[key] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.customRef)(() => ({ 34260 get() { 34261 return objectRef.value[key]; 34262 }, 34263 set(v) { 34264 var _a; 34265 const replaceRef = (_a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(options.replaceRef)) != null ? _a : true; 34266 if (replaceRef) { 34267 if (Array.isArray(objectRef.value)) { 34268 const copy = [...objectRef.value]; 34269 copy[key] = v; 34270 objectRef.value = copy; 34271 } else { 34272 const newObject = { ...objectRef.value, [key]: v }; 34273 Object.setPrototypeOf(newObject, Object.getPrototypeOf(objectRef.value)); 34274 objectRef.value = newObject; 34275 } 34276 } else { 34277 objectRef.value[key] = v; 34278 } 34279 } 34280 })); 34281 } 34282 return result; 34283} 34284 34285const toValue = vue__WEBPACK_IMPORTED_MODULE_0__.toValue; 34286const resolveUnref = vue__WEBPACK_IMPORTED_MODULE_0__.toValue; 34287 34288function tryOnBeforeMount(fn, sync = true, target) { 34289 const instance = getLifeCycleTarget(target); 34290 if (instance) 34291 (0,vue__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount)(fn, target); 34292 else if (sync) 34293 fn(); 34294 else 34295 (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(fn); 34296} 34297 34298function tryOnBeforeUnmount(fn, target) { 34299 const instance = getLifeCycleTarget(target); 34300 if (instance) 34301 (0,vue__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount)(fn, target); 34302} 34303 34304function tryOnMounted(fn, sync = true, target) { 34305 const instance = getLifeCycleTarget(); 34306 if (instance) 34307 (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(fn, target); 34308 else if (sync) 34309 fn(); 34310 else 34311 (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(fn); 34312} 34313 34314function tryOnUnmounted(fn, target) { 34315 const instance = getLifeCycleTarget(target); 34316 if (instance) 34317 (0,vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(fn, target); 34318} 34319 34320function createUntil(r, isNot = false) { 34321 function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) { 34322 let stop = null; 34323 const watcher = new Promise((resolve) => { 34324 stop = (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 34325 r, 34326 (v) => { 34327 if (condition(v) !== isNot) { 34328 if (stop) 34329 stop(); 34330 else 34331 (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => stop == null ? undefined : stop()); 34332 resolve(v); 34333 } 34334 }, 34335 { 34336 flush, 34337 deep, 34338 immediate: true 34339 } 34340 ); 34341 }); 34342 const promises = [watcher]; 34343 if (timeout != null) { 34344 promises.push( 34345 promiseTimeout(timeout, throwOnTimeout).then(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(r)).finally(() => stop == null ? undefined : stop()) 34346 ); 34347 } 34348 return Promise.race(promises); 34349 } 34350 function toBe(value, options) { 34351 if (!(0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(value)) 34352 return toMatch((v) => v === value, options); 34353 const { flush = "sync", deep = false, timeout, throwOnTimeout } = options != null ? options : {}; 34354 let stop = null; 34355 const watcher = new Promise((resolve) => { 34356 stop = (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 34357 [r, value], 34358 ([v1, v2]) => { 34359 if (isNot !== (v1 === v2)) { 34360 if (stop) 34361 stop(); 34362 else 34363 (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => stop == null ? undefined : stop()); 34364 resolve(v1); 34365 } 34366 }, 34367 { 34368 flush, 34369 deep, 34370 immediate: true 34371 } 34372 ); 34373 }); 34374 const promises = [watcher]; 34375 if (timeout != null) { 34376 promises.push( 34377 promiseTimeout(timeout, throwOnTimeout).then(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(r)).finally(() => { 34378 stop == null ? undefined : stop(); 34379 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(r); 34380 }) 34381 ); 34382 } 34383 return Promise.race(promises); 34384 } 34385 function toBeTruthy(options) { 34386 return toMatch((v) => Boolean(v), options); 34387 } 34388 function toBeNull(options) { 34389 return toBe(null, options); 34390 } 34391 function toBeUndefined(options) { 34392 return toBe(undefined, options); 34393 } 34394 function toBeNaN(options) { 34395 return toMatch(Number.isNaN, options); 34396 } 34397 function toContains(value, options) { 34398 return toMatch((v) => { 34399 const array = Array.from(v); 34400 return array.includes(value) || array.includes((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(value)); 34401 }, options); 34402 } 34403 function changed(options) { 34404 return changedTimes(1, options); 34405 } 34406 function changedTimes(n = 1, options) { 34407 let count = -1; 34408 return toMatch(() => { 34409 count += 1; 34410 return count >= n; 34411 }, options); 34412 } 34413 if (Array.isArray((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(r))) { 34414 const instance = { 34415 toMatch, 34416 toContains, 34417 changed, 34418 changedTimes, 34419 get not() { 34420 return createUntil(r, !isNot); 34421 } 34422 }; 34423 return instance; 34424 } else { 34425 const instance = { 34426 toMatch, 34427 toBe, 34428 toBeTruthy, 34429 toBeNull, 34430 toBeNaN, 34431 toBeUndefined, 34432 changed, 34433 changedTimes, 34434 get not() { 34435 return createUntil(r, !isNot); 34436 } 34437 }; 34438 return instance; 34439 } 34440} 34441function until(r) { 34442 return createUntil(r); 34443} 34444 34445function defaultComparator(value, othVal) { 34446 return value === othVal; 34447} 34448function useArrayDifference(...args) { 34449 var _a, _b; 34450 const list = args[0]; 34451 const values = args[1]; 34452 let compareFn = (_a = args[2]) != null ? _a : defaultComparator; 34453 const { 34454 symmetric = false 34455 } = (_b = args[3]) != null ? _b : {}; 34456 if (typeof compareFn === "string") { 34457 const key = compareFn; 34458 compareFn = (value, othVal) => value[key] === othVal[key]; 34459 } 34460 const diff1 = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).filter((x) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(values).findIndex((y) => compareFn(x, y)) === -1)); 34461 if (symmetric) { 34462 const diff2 = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(values).filter((x) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).findIndex((y) => compareFn(x, y)) === -1)); 34463 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => symmetric ? [...(0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(diff1), ...(0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(diff2)] : (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(diff1)); 34464 } else { 34465 return diff1; 34466 } 34467} 34468 34469function useArrayEvery(list, fn) { 34470 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).every((element, index, array) => fn((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(element), index, array))); 34471} 34472 34473function useArrayFilter(list, fn) { 34474 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).map((i) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(i)).filter(fn)); 34475} 34476 34477function useArrayFind(list, fn) { 34478 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)( 34479 (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).find((element, index, array) => fn((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(element), index, array)) 34480 )); 34481} 34482 34483function useArrayFindIndex(list, fn) { 34484 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).findIndex((element, index, array) => fn((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(element), index, array))); 34485} 34486 34487function findLast(arr, cb) { 34488 let index = arr.length; 34489 while (index-- > 0) { 34490 if (cb(arr[index], index, arr)) 34491 return arr[index]; 34492 } 34493 return undefined; 34494} 34495function useArrayFindLast(list, fn) { 34496 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)( 34497 !Array.prototype.findLast ? findLast((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list), (element, index, array) => fn((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(element), index, array)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).findLast((element, index, array) => fn((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(element), index, array)) 34498 )); 34499} 34500 34501function isArrayIncludesOptions(obj) { 34502 return isObject(obj) && containsProp(obj, "formIndex", "comparator"); 34503} 34504function useArrayIncludes(...args) { 34505 var _a; 34506 const list = args[0]; 34507 const value = args[1]; 34508 let comparator = args[2]; 34509 let formIndex = 0; 34510 if (isArrayIncludesOptions(comparator)) { 34511 formIndex = (_a = comparator.fromIndex) != null ? _a : 0; 34512 comparator = comparator.comparator; 34513 } 34514 if (typeof comparator === "string") { 34515 const key = comparator; 34516 comparator = (element, value2) => element[key] === (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(value2); 34517 } 34518 comparator = comparator != null ? comparator : (element, value2) => element === (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(value2); 34519 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).slice(formIndex).some((element, index, array) => comparator( 34520 (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(element), 34521 (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(value), 34522 index, 34523 (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(array) 34524 ))); 34525} 34526 34527function useArrayJoin(list, separator) { 34528 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).map((i) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(i)).join((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(separator))); 34529} 34530 34531function useArrayMap(list, fn) { 34532 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).map((i) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(i)).map(fn)); 34533} 34534 34535function useArrayReduce(list, reducer, ...args) { 34536 const reduceCallback = (sum, value, index) => reducer((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(sum), (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(value), index); 34537 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 34538 const resolved = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list); 34539 return args.length ? resolved.reduce(reduceCallback, typeof args[0] === "function" ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(args[0]()) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(args[0])) : resolved.reduce(reduceCallback); 34540 }); 34541} 34542 34543function useArraySome(list, fn) { 34544 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).some((element, index, array) => fn((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(element), index, array))); 34545} 34546 34547function uniq(array) { 34548 return Array.from(new Set(array)); 34549} 34550function uniqueElementsBy(array, fn) { 34551 return array.reduce((acc, v) => { 34552 if (!acc.some((x) => fn(v, x, array))) 34553 acc.push(v); 34554 return acc; 34555 }, []); 34556} 34557function useArrayUnique(list, compareFn) { 34558 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 34559 const resolvedList = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(list).map((element) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(element)); 34560 return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList); 34561 }); 34562} 34563 34564function useCounter(initialValue = 0, options = {}) { 34565 let _initialValue = (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(initialValue); 34566 const count = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(initialValue); 34567 const { 34568 max = Number.POSITIVE_INFINITY, 34569 min = Number.NEGATIVE_INFINITY 34570 } = options; 34571 const inc = (delta = 1) => count.value = Math.max(Math.min(max, count.value + delta), min); 34572 const dec = (delta = 1) => count.value = Math.min(Math.max(min, count.value - delta), max); 34573 const get = () => count.value; 34574 const set = (val) => count.value = Math.max(min, Math.min(max, val)); 34575 const reset = (val = _initialValue) => { 34576 _initialValue = val; 34577 return set(val); 34578 }; 34579 return { count, inc, dec, get, set, reset }; 34580} 34581 34582const REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[T\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/i; 34583const REGEX_FORMAT = /[YMDHhms]o|\[([^\]]+)\]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a{1,2}|A{1,2}|m{1,2}|s{1,2}|Z{1,2}|SSS/g; 34584function defaultMeridiem(hours, minutes, isLowercase, hasPeriod) { 34585 let m = hours < 12 ? "AM" : "PM"; 34586 if (hasPeriod) 34587 m = m.split("").reduce((acc, curr) => acc += `${curr}.`, ""); 34588 return isLowercase ? m.toLowerCase() : m; 34589} 34590function formatOrdinal(num) { 34591 const suffixes = ["th", "st", "nd", "rd"]; 34592 const v = num % 100; 34593 return num + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]); 34594} 34595function formatDate(date, formatStr, options = {}) { 34596 var _a; 34597 const years = date.getFullYear(); 34598 const month = date.getMonth(); 34599 const days = date.getDate(); 34600 const hours = date.getHours(); 34601 const minutes = date.getMinutes(); 34602 const seconds = date.getSeconds(); 34603 const milliseconds = date.getMilliseconds(); 34604 const day = date.getDay(); 34605 const meridiem = (_a = options.customMeridiem) != null ? _a : defaultMeridiem; 34606 const matches = { 34607 Yo: () => formatOrdinal(years), 34608 YY: () => String(years).slice(-2), 34609 YYYY: () => years, 34610 M: () => month + 1, 34611 Mo: () => formatOrdinal(month + 1), 34612 MM: () => `${month + 1}`.padStart(2, "0"), 34613 MMM: () => date.toLocaleDateString((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(options.locales), { month: "short" }), 34614 MMMM: () => date.toLocaleDateString((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(options.locales), { month: "long" }), 34615 D: () => String(days), 34616 Do: () => formatOrdinal(days), 34617 DD: () => `${days}`.padStart(2, "0"), 34618 H: () => String(hours), 34619 Ho: () => formatOrdinal(hours), 34620 HH: () => `${hours}`.padStart(2, "0"), 34621 h: () => `${hours % 12 || 12}`.padStart(1, "0"), 34622 ho: () => formatOrdinal(hours % 12 || 12), 34623 hh: () => `${hours % 12 || 12}`.padStart(2, "0"), 34624 m: () => String(minutes), 34625 mo: () => formatOrdinal(minutes), 34626 mm: () => `${minutes}`.padStart(2, "0"), 34627 s: () => String(seconds), 34628 so: () => formatOrdinal(seconds), 34629 ss: () => `${seconds}`.padStart(2, "0"), 34630 SSS: () => `${milliseconds}`.padStart(3, "0"), 34631 d: () => day, 34632 dd: () => date.toLocaleDateString((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(options.locales), { weekday: "narrow" }), 34633 ddd: () => date.toLocaleDateString((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(options.locales), { weekday: "short" }), 34634 dddd: () => date.toLocaleDateString((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(options.locales), { weekday: "long" }), 34635 A: () => meridiem(hours, minutes), 34636 AA: () => meridiem(hours, minutes, false, true), 34637 a: () => meridiem(hours, minutes, true), 34638 aa: () => meridiem(hours, minutes, true, true) 34639 }; 34640 return formatStr.replace(REGEX_FORMAT, (match, $1) => { 34641 var _a2, _b; 34642 return (_b = $1 != null ? $1 : (_a2 = matches[match]) == null ? undefined : _a2.call(matches)) != null ? _b : match; 34643 }); 34644} 34645function normalizeDate(date) { 34646 if (date === null) 34647 return new Date(Number.NaN); 34648 if (date === undefined) 34649 return /* @__PURE__ */ new Date(); 34650 if (date instanceof Date) 34651 return new Date(date); 34652 if (typeof date === "string" && !/Z$/i.test(date)) { 34653 const d = date.match(REGEX_PARSE); 34654 if (d) { 34655 const m = d[2] - 1 || 0; 34656 const ms = (d[7] || "0").substring(0, 3); 34657 return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms); 34658 } 34659 } 34660 return new Date(date); 34661} 34662function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) { 34663 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => formatDate(normalizeDate((0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(date)), (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(formatStr), options)); 34664} 34665 34666function useIntervalFn(cb, interval = 1e3, options = {}) { 34667 const { 34668 immediate = true, 34669 immediateCallback = false 34670 } = options; 34671 let timer = null; 34672 const isActive = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(false); 34673 function clean() { 34674 if (timer) { 34675 clearInterval(timer); 34676 timer = null; 34677 } 34678 } 34679 function pause() { 34680 isActive.value = false; 34681 clean(); 34682 } 34683 function resume() { 34684 const intervalValue = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(interval); 34685 if (intervalValue <= 0) 34686 return; 34687 isActive.value = true; 34688 if (immediateCallback) 34689 cb(); 34690 clean(); 34691 if (isActive.value) 34692 timer = setInterval(cb, intervalValue); 34693 } 34694 if (immediate && isClient) 34695 resume(); 34696 if ((0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(interval) || typeof interval === "function") { 34697 const stopWatch = (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(interval, () => { 34698 if (isActive.value && isClient) 34699 resume(); 34700 }); 34701 tryOnScopeDispose(stopWatch); 34702 } 34703 tryOnScopeDispose(pause); 34704 return { 34705 isActive, 34706 pause, 34707 resume 34708 }; 34709} 34710 34711function useInterval(interval = 1e3, options = {}) { 34712 const { 34713 controls: exposeControls = false, 34714 immediate = true, 34715 callback 34716 } = options; 34717 const counter = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0); 34718 const update = () => counter.value += 1; 34719 const reset = () => { 34720 counter.value = 0; 34721 }; 34722 const controls = useIntervalFn( 34723 callback ? () => { 34724 update(); 34725 callback(counter.value); 34726 } : update, 34727 interval, 34728 { immediate } 34729 ); 34730 if (exposeControls) { 34731 return { 34732 counter, 34733 reset, 34734 ...controls 34735 }; 34736 } else { 34737 return counter; 34738 } 34739} 34740 34741function useLastChanged(source, options = {}) { 34742 var _a; 34743 const ms = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)((_a = options.initialValue) != null ? _a : null); 34744 (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 34745 source, 34746 () => ms.value = timestamp(), 34747 options 34748 ); 34749 return ms; 34750} 34751 34752function useTimeoutFn(cb, interval, options = {}) { 34753 const { 34754 immediate = true 34755 } = options; 34756 const isPending = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(false); 34757 let timer = null; 34758 function clear() { 34759 if (timer) { 34760 clearTimeout(timer); 34761 timer = null; 34762 } 34763 } 34764 function stop() { 34765 isPending.value = false; 34766 clear(); 34767 } 34768 function start(...args) { 34769 clear(); 34770 isPending.value = true; 34771 timer = setTimeout(() => { 34772 isPending.value = false; 34773 timer = null; 34774 cb(...args); 34775 }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(interval)); 34776 } 34777 if (immediate) { 34778 isPending.value = true; 34779 if (isClient) 34780 start(); 34781 } 34782 tryOnScopeDispose(stop); 34783 return { 34784 isPending: (0,vue__WEBPACK_IMPORTED_MODULE_0__.readonly)(isPending), 34785 start, 34786 stop 34787 }; 34788} 34789 34790function useTimeout(interval = 1e3, options = {}) { 34791 const { 34792 controls: exposeControls = false, 34793 callback 34794 } = options; 34795 const controls = useTimeoutFn( 34796 callback != null ? callback : noop, 34797 interval, 34798 options 34799 ); 34800 const ready = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !controls.isPending.value); 34801 if (exposeControls) { 34802 return { 34803 ready, 34804 ...controls 34805 }; 34806 } else { 34807 return ready; 34808 } 34809} 34810 34811function useToNumber(value, options = {}) { 34812 const { 34813 method = "parseFloat", 34814 radix, 34815 nanToZero 34816 } = options; 34817 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 34818 let resolved = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(value); 34819 if (typeof method === "function") 34820 resolved = method(resolved); 34821 else if (typeof resolved === "string") 34822 resolved = Number[method](resolved, radix); 34823 if (nanToZero && Number.isNaN(resolved)) 34824 resolved = 0; 34825 return resolved; 34826 }); 34827} 34828 34829function useToString(value) { 34830 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(value)}`); 34831} 34832 34833function useToggle(initialValue = false, options = {}) { 34834 const { 34835 truthyValue = true, 34836 falsyValue = false 34837 } = options; 34838 const valueIsRef = (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(initialValue); 34839 const _value = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(initialValue); 34840 function toggle(value) { 34841 if (arguments.length) { 34842 _value.value = value; 34843 return _value.value; 34844 } else { 34845 const truthy = (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(truthyValue); 34846 _value.value = _value.value === truthy ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(falsyValue) : truthy; 34847 return _value.value; 34848 } 34849 } 34850 if (valueIsRef) 34851 return toggle; 34852 else 34853 return [_value, toggle]; 34854} 34855 34856function watchArray(source, cb, options) { 34857 let oldList = (options == null ? undefined : options.immediate) ? [] : [...source instanceof Function ? source() : Array.isArray(source) ? source : (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(source)]; 34858 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(source, (newList, _, onCleanup) => { 34859 const oldListRemains = Array.from({ length: oldList.length }); 34860 const added = []; 34861 for (const obj of newList) { 34862 let found = false; 34863 for (let i = 0; i < oldList.length; i++) { 34864 if (!oldListRemains[i] && obj === oldList[i]) { 34865 oldListRemains[i] = true; 34866 found = true; 34867 break; 34868 } 34869 } 34870 if (!found) 34871 added.push(obj); 34872 } 34873 const removed = oldList.filter((_2, i) => !oldListRemains[i]); 34874 cb(newList, oldList, added, removed, onCleanup); 34875 oldList = [...newList]; 34876 }, options); 34877} 34878 34879function watchAtMost(source, cb, options) { 34880 const { 34881 count, 34882 ...watchOptions 34883 } = options; 34884 const current = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0); 34885 const stop = watchWithFilter( 34886 source, 34887 (...args) => { 34888 current.value += 1; 34889 if (current.value >= (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(count)) 34890 (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => stop()); 34891 cb(...args); 34892 }, 34893 watchOptions 34894 ); 34895 return { count: current, stop }; 34896} 34897 34898function watchDebounced(source, cb, options = {}) { 34899 const { 34900 debounce = 0, 34901 maxWait = undefined, 34902 ...watchOptions 34903 } = options; 34904 return watchWithFilter( 34905 source, 34906 cb, 34907 { 34908 ...watchOptions, 34909 eventFilter: debounceFilter(debounce, { maxWait }) 34910 } 34911 ); 34912} 34913 34914function watchDeep(source, cb, options) { 34915 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 34916 source, 34917 cb, 34918 { 34919 ...options, 34920 deep: true 34921 } 34922 ); 34923} 34924 34925function watchIgnorable(source, cb, options = {}) { 34926 const { 34927 eventFilter = bypassFilter, 34928 ...watchOptions 34929 } = options; 34930 const filteredCb = createFilterWrapper( 34931 eventFilter, 34932 cb 34933 ); 34934 let ignoreUpdates; 34935 let ignorePrevAsyncUpdates; 34936 let stop; 34937 if (watchOptions.flush === "sync") { 34938 const ignore = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(false); 34939 ignorePrevAsyncUpdates = () => { 34940 }; 34941 ignoreUpdates = (updater) => { 34942 ignore.value = true; 34943 updater(); 34944 ignore.value = false; 34945 }; 34946 stop = (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 34947 source, 34948 (...args) => { 34949 if (!ignore.value) 34950 filteredCb(...args); 34951 }, 34952 watchOptions 34953 ); 34954 } else { 34955 const disposables = []; 34956 const ignoreCounter = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0); 34957 const syncCounter = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0); 34958 ignorePrevAsyncUpdates = () => { 34959 ignoreCounter.value = syncCounter.value; 34960 }; 34961 disposables.push( 34962 (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 34963 source, 34964 () => { 34965 syncCounter.value++; 34966 }, 34967 { ...watchOptions, flush: "sync" } 34968 ) 34969 ); 34970 ignoreUpdates = (updater) => { 34971 const syncCounterPrev = syncCounter.value; 34972 updater(); 34973 ignoreCounter.value += syncCounter.value - syncCounterPrev; 34974 }; 34975 disposables.push( 34976 (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 34977 source, 34978 (...args) => { 34979 const ignore = ignoreCounter.value > 0 && ignoreCounter.value === syncCounter.value; 34980 ignoreCounter.value = 0; 34981 syncCounter.value = 0; 34982 if (ignore) 34983 return; 34984 filteredCb(...args); 34985 }, 34986 watchOptions 34987 ) 34988 ); 34989 stop = () => { 34990 disposables.forEach((fn) => fn()); 34991 }; 34992 } 34993 return { stop, ignoreUpdates, ignorePrevAsyncUpdates }; 34994} 34995 34996function watchImmediate(source, cb, options) { 34997 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 34998 source, 34999 cb, 35000 { 35001 ...options, 35002 immediate: true 35003 } 35004 ); 35005} 35006 35007function watchOnce(source, cb, options) { 35008 const stop = (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(source, (...args) => { 35009 (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => stop()); 35010 return cb(...args); 35011 }, options); 35012 return stop; 35013} 35014 35015function watchThrottled(source, cb, options = {}) { 35016 const { 35017 throttle = 0, 35018 trailing = true, 35019 leading = true, 35020 ...watchOptions 35021 } = options; 35022 return watchWithFilter( 35023 source, 35024 cb, 35025 { 35026 ...watchOptions, 35027 eventFilter: throttleFilter(throttle, trailing, leading) 35028 } 35029 ); 35030} 35031 35032function watchTriggerable(source, cb, options = {}) { 35033 let cleanupFn; 35034 function onEffect() { 35035 if (!cleanupFn) 35036 return; 35037 const fn = cleanupFn; 35038 cleanupFn = undefined; 35039 fn(); 35040 } 35041 function onCleanup(callback) { 35042 cleanupFn = callback; 35043 } 35044 const _cb = (value, oldValue) => { 35045 onEffect(); 35046 return cb(value, oldValue, onCleanup); 35047 }; 35048 const res = watchIgnorable(source, _cb, options); 35049 const { ignoreUpdates } = res; 35050 const trigger = () => { 35051 let res2; 35052 ignoreUpdates(() => { 35053 res2 = _cb(getWatchSources(source), getOldValue(source)); 35054 }); 35055 return res2; 35056 }; 35057 return { 35058 ...res, 35059 trigger 35060 }; 35061} 35062function getWatchSources(sources) { 35063 if ((0,vue__WEBPACK_IMPORTED_MODULE_0__.isReactive)(sources)) 35064 return sources; 35065 if (Array.isArray(sources)) 35066 return sources.map((item) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(item)); 35067 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.toValue)(sources); 35068} 35069function getOldValue(source) { 35070 return Array.isArray(source) ? source.map(() => undefined) : undefined; 35071} 35072 35073function whenever(source, cb, options) { 35074 const stop = (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 35075 source, 35076 (v, ov, onInvalidate) => { 35077 if (v) { 35078 if (options == null ? undefined : options.once) 35079 (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => stop()); 35080 cb(v, ov, onInvalidate); 35081 } 35082 }, 35083 { 35084 ...options, 35085 once: false 35086 } 35087 ); 35088 return stop; 35089} 35090 35091 35092 35093 35094/***/ }), 35095
vendor: 3,490 bytes, lines 35096-35194
35096/***/ "./node_modules/axios/lib/adapters/adapters.js": 35097/*!*****************************************************!*\ 35098 !*** ./node_modules/axios/lib/adapters/adapters.js ***! 35099 \*****************************************************/ 35100/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 35101 35102"use strict"; 35103__webpack_require__.r(__webpack_exports__); 35104/* harmony export */ __webpack_require__.d(__webpack_exports__, { 35105/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 35106/* harmony export */ }); 35107/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 35108/* harmony import */ var _http_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./http.js */ "./node_modules/axios/lib/helpers/null.js"); 35109/* harmony import */ var _xhr_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./xhr.js */ "./node_modules/axios/lib/adapters/xhr.js"); 35110/* harmony import */ var _fetch_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./fetch.js */ "./node_modules/axios/lib/adapters/fetch.js"); 35111/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js"); 35112 35113 35114 35115 35116 35117 35118const knownAdapters = { 35119 http: _http_js__WEBPACK_IMPORTED_MODULE_0__["default"], 35120 xhr: _xhr_js__WEBPACK_IMPORTED_MODULE_1__["default"], 35121 fetch: _fetch_js__WEBPACK_IMPORTED_MODULE_2__["default"] 35122} 35123 35124_utils_js__WEBPACK_IMPORTED_MODULE_3__["default"].forEach(knownAdapters, (fn, value) => { 35125 if (fn) { 35126 try { 35127 Object.defineProperty(fn, 'name', {value}); 35128 } catch (e) { 35129 // eslint-disable-next-line no-empty 35130 } 35131 Object.defineProperty(fn, 'adapterName', {value}); 35132 } 35133}); 35134 35135const renderReason = (reason) => `- ${reason}`; 35136 35137const isResolvedHandle = (adapter) => _utils_js__WEBPACK_IMPORTED_MODULE_3__["default"].isFunction(adapter) || adapter === null || adapter === false; 35138 35139/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({ 35140 getAdapter: (adapters) => { 35141 adapters = _utils_js__WEBPACK_IMPORTED_MODULE_3__["default"].isArray(adapters) ? adapters : [adapters]; 35142 35143 const {length} = adapters; 35144 let nameOrAdapter; 35145 let adapter; 35146 35147 const rejectedReasons = {}; 35148 35149 for (let i = 0; i < length; i++) { 35150 nameOrAdapter = adapters[i]; 35151 let id; 35152 35153 adapter = nameOrAdapter; 35154 35155 if (!isResolvedHandle(nameOrAdapter)) { 35156 adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()]; 35157 35158 if (adapter === undefined) { 35159 throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_4__["default"](`Unknown adapter '${id}'`); 35160 } 35161 } 35162 35163 if (adapter) { 35164 break; 35165 } 35166 35167 rejectedReasons[id || '#' + i] = adapter; 35168 } 35169 35170 if (!adapter) { 35171 35172 const reasons = Object.entries(rejectedReasons) 35173 .map(([id, state]) => `adapter ${id} ` + 35174 (state === false ? 'is not supported by the environment' : 'is not available in the build') 35175 ); 35176 35177 let s = length ? 35178 (reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0])) : 35179 'as no adapter specified'; 35180 35181 throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_4__["default"]( 35182 `There is no suitable adapter to dispatch the request ` + s, 35183 'ERR_NOT_SUPPORT' 35184 ); 35185 } 35186 35187 return adapter; 35188 }, 35189 adapters: knownAdapters 35190}); 35191 35192 35193/***/ }), 35194
vendor: 9,987 bytes, lines 35195-35447
35195/***/ "./node_modules/axios/lib/adapters/fetch.js": 35196/*!**************************************************!*\ 35197 !*** ./node_modules/axios/lib/adapters/fetch.js ***! 35198 \**************************************************/ 35199/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 35200 35201"use strict"; 35202__webpack_require__.r(__webpack_exports__); 35203/* harmony export */ __webpack_require__.d(__webpack_exports__, { 35204/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 35205/* harmony export */ }); 35206/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js"); 35207/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 35208/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js"); 35209/* harmony import */ var _helpers_composeSignals_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../helpers/composeSignals.js */ "./node_modules/axios/lib/helpers/composeSignals.js"); 35210/* harmony import */ var _helpers_trackStream_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../helpers/trackStream.js */ "./node_modules/axios/lib/helpers/trackStream.js"); 35211/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js"); 35212/* harmony import */ var _helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../helpers/progressEventReducer.js */ "./node_modules/axios/lib/helpers/progressEventReducer.js"); 35213/* harmony import */ var _helpers_resolveConfig_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../helpers/resolveConfig.js */ "./node_modules/axios/lib/helpers/resolveConfig.js"); 35214/* harmony import */ var _core_settle_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../core/settle.js */ "./node_modules/axios/lib/core/settle.js"); 35215 35216 35217 35218 35219 35220 35221 35222 35223 35224 35225const isFetchSupported = typeof fetch === 'function' && typeof Request === 'function' && typeof Response === 'function'; 35226const isReadableStreamSupported = isFetchSupported && typeof ReadableStream === 'function'; 35227 35228// used only inside the fetch adapter 35229const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ? 35230 ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : 35231 async (str) => new Uint8Array(await new Response(str).arrayBuffer()) 35232); 35233 35234const test = (fn, ...args) => { 35235 try { 35236 return !!fn(...args); 35237 } catch (e) { 35238 return false 35239 } 35240} 35241 35242const supportsRequestStream = isReadableStreamSupported && test(() => { 35243 let duplexAccessed = false; 35244 35245 const hasContentType = new Request(_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].origin, { 35246 body: new ReadableStream(), 35247 method: 'POST', 35248 get duplex() { 35249 duplexAccessed = true; 35250 return 'half'; 35251 }, 35252 }).headers.has('Content-Type'); 35253 35254 return duplexAccessed && !hasContentType; 35255}); 35256 35257const DEFAULT_CHUNK_SIZE = 64 * 1024; 35258 35259const supportsResponseStream = isReadableStreamSupported && 35260 test(() => _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isReadableStream(new Response('').body)); 35261 35262 35263const resolvers = { 35264 stream: supportsResponseStream && ((res) => res.body) 35265}; 35266 35267isFetchSupported && (((res) => { 35268 ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => { 35269 !resolvers[type] && (resolvers[type] = _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isFunction(res[type]) ? (res) => res[type]() : 35270 (_, config) => { 35271 throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"](`Response type '${type}' is not supported`, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"].ERR_NOT_SUPPORT, config); 35272 }) 35273 }); 35274})(new Response)); 35275 35276const getBodyLength = async (body) => { 35277 if (body == null) { 35278 return 0; 35279 } 35280 35281 if(_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isBlob(body)) { 35282 return body.size; 35283 } 35284 35285 if(_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isSpecCompliantForm(body)) { 35286 const _request = new Request(_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].origin, { 35287 method: 'POST', 35288 body, 35289 }); 35290 return (await _request.arrayBuffer()).byteLength; 35291 } 35292 35293 if(_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isArrayBufferView(body) || _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isArrayBuffer(body)) { 35294 return body.byteLength; 35295 } 35296 35297 if(_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isURLSearchParams(body)) { 35298 body = body + ''; 35299 } 35300 35301 if(_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isString(body)) { 35302 return (await encodeText(body)).byteLength; 35303 } 35304} 35305 35306const resolveBodyLength = async (headers, body) => { 35307 const length = _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].toFiniteNumber(headers.getContentLength()); 35308 35309 return length == null ? getBodyLength(body) : length; 35310} 35311 35312/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (isFetchSupported && (async (config) => { 35313 let { 35314 url, 35315 method, 35316 data, 35317 signal, 35318 cancelToken, 35319 timeout, 35320 onDownloadProgress, 35321 onUploadProgress, 35322 responseType, 35323 headers, 35324 withCredentials = 'same-origin', 35325 fetchOptions 35326 } = (0,_helpers_resolveConfig_js__WEBPACK_IMPORTED_MODULE_3__["default"])(config); 35327 35328 responseType = responseType ? (responseType + '').toLowerCase() : 'text'; 35329 35330 let composedSignal = (0,_helpers_composeSignals_js__WEBPACK_IMPORTED_MODULE_4__["default"])([signal, cancelToken && cancelToken.toAbortSignal()], timeout); 35331 35332 let request; 35333 35334 const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => { 35335 composedSignal.unsubscribe(); 35336 }); 35337 35338 let requestContentLength; 35339 35340 try { 35341 if ( 35342 onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' && 35343 (requestContentLength = await resolveBodyLength(headers, data)) !== 0 35344 ) { 35345 let _request = new Request(url, { 35346 method: 'POST', 35347 body: data, 35348 duplex: "half" 35349 }); 35350 35351 let contentTypeHeader; 35352 35353 if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) { 35354 headers.setContentType(contentTypeHeader) 35355 } 35356 35357 if (_request.body) { 35358 const [onProgress, flush] = (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_5__.progressEventDecorator)( 35359 requestContentLength, 35360 (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_5__.progressEventReducer)((0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_5__.asyncDecorator)(onUploadProgress)) 35361 ); 35362 35363 data = (0,_helpers_trackStream_js__WEBPACK_IMPORTED_MODULE_6__.trackStream)(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush); 35364 } 35365 } 35366 35367 if (!_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isString(withCredentials)) { 35368 withCredentials = withCredentials ? 'include' : 'omit'; 35369 } 35370 35371 // Cloudflare Workers throws when credentials are defined 35372 // see https://github.com/cloudflare/workerd/issues/902 35373 const isCredentialsSupported = "credentials" in Request.prototype; 35374 request = new Request(url, { 35375 ...fetchOptions, 35376 signal: composedSignal, 35377 method: method.toUpperCase(), 35378 headers: headers.normalize().toJSON(), 35379 body: data, 35380 duplex: "half", 35381 credentials: isCredentialsSupported ? withCredentials : undefined 35382 }); 35383 35384 let response = await fetch(request); 35385 35386 const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response'); 35387 35388 if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) { 35389 const options = {}; 35390 35391 ['status', 'statusText', 'headers'].forEach(prop => { 35392 options[prop] = response[prop]; 35393 }); 35394 35395 const responseContentLength = _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].toFiniteNumber(response.headers.get('content-length')); 35396 35397 const [onProgress, flush] = onDownloadProgress && (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_5__.progressEventDecorator)( 35398 responseContentLength, 35399 (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_5__.progressEventReducer)((0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_5__.asyncDecorator)(onDownloadProgress), true) 35400 ) || []; 35401 35402 response = new Response( 35403 (0,_helpers_trackStream_js__WEBPACK_IMPORTED_MODULE_6__.trackStream)(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => { 35404 flush && flush(); 35405 unsubscribe && unsubscribe(); 35406 }), 35407 options 35408 ); 35409 } 35410 35411 responseType = responseType || 'text'; 35412 35413 let responseData = await resolvers[_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].findKey(resolvers, responseType) || 'text'](response, config); 35414 35415 !isStreamResponse && unsubscribe && unsubscribe(); 35416 35417 return await new Promise((resolve, reject) => { 35418 (0,_core_settle_js__WEBPACK_IMPORTED_MODULE_7__["default"])(resolve, reject, { 35419 data: responseData, 35420 headers: _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_8__["default"].from(response.headers), 35421 status: response.status, 35422 statusText: response.statusText, 35423 config, 35424 request 35425 }) 35426 }) 35427 } catch (err) { 35428 unsubscribe && unsubscribe(); 35429 35430 if (err && err.name === 'TypeError' && /fetch/i.test(err.message)) { 35431 throw Object.assign( 35432 new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"]('Network Error', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"].ERR_NETWORK, config, request), 35433 { 35434 cause: err.cause || err 35435 } 35436 ) 35437 } 35438 35439 throw _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"].from(err, err && err.code, config, request); 35440 } 35441})); 35442 35443 35444 35445 35446/***/ }), 35447
vendor: 9,564 bytes, lines 35448-35669
35448/***/ "./node_modules/axios/lib/adapters/xhr.js": 35449/*!************************************************!*\ 35450 !*** ./node_modules/axios/lib/adapters/xhr.js ***! 35451 \************************************************/ 35452/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 35453 35454"use strict"; 35455__webpack_require__.r(__webpack_exports__); 35456/* harmony export */ __webpack_require__.d(__webpack_exports__, { 35457/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 35458/* harmony export */ }); 35459/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js"); 35460/* harmony import */ var _core_settle_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./../core/settle.js */ "./node_modules/axios/lib/core/settle.js"); 35461/* harmony import */ var _defaults_transitional_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../defaults/transitional.js */ "./node_modules/axios/lib/defaults/transitional.js"); 35462/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js"); 35463/* harmony import */ var _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../cancel/CanceledError.js */ "./node_modules/axios/lib/cancel/CanceledError.js"); 35464/* harmony import */ var _helpers_parseProtocol_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../helpers/parseProtocol.js */ "./node_modules/axios/lib/helpers/parseProtocol.js"); 35465/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js"); 35466/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js"); 35467/* harmony import */ var _helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../helpers/progressEventReducer.js */ "./node_modules/axios/lib/helpers/progressEventReducer.js"); 35468/* harmony import */ var _helpers_resolveConfig_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../helpers/resolveConfig.js */ "./node_modules/axios/lib/helpers/resolveConfig.js"); 35469 35470 35471 35472 35473 35474 35475 35476 35477 35478 35479 35480const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined'; 35481 35482/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (isXHRAdapterSupported && function (config) { 35483 return new Promise(function dispatchXhrRequest(resolve, reject) { 35484 const _config = (0,_helpers_resolveConfig_js__WEBPACK_IMPORTED_MODULE_0__["default"])(config); 35485 let requestData = _config.data; 35486 const requestHeaders = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"].from(_config.headers).normalize(); 35487 let {responseType, onUploadProgress, onDownloadProgress} = _config; 35488 let onCanceled; 35489 let uploadThrottled, downloadThrottled; 35490 let flushUpload, flushDownload; 35491 35492 function done() { 35493 flushUpload && flushUpload(); // flush events 35494 flushDownload && flushDownload(); // flush events 35495 35496 _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled); 35497 35498 _config.signal && _config.signal.removeEventListener('abort', onCanceled); 35499 } 35500 35501 let request = new XMLHttpRequest(); 35502 35503 request.open(_config.method.toUpperCase(), _config.url, true); 35504 35505 // Set the request timeout in MS 35506 request.timeout = _config.timeout; 35507 35508 function onloadend() { 35509 if (!request) { 35510 return; 35511 } 35512 // Prepare the response 35513 const responseHeaders = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"].from( 35514 'getAllResponseHeaders' in request && request.getAllResponseHeaders() 35515 ); 35516 const responseData = !responseType || responseType === 'text' || responseType === 'json' ? 35517 request.responseText : request.response; 35518 const response = { 35519 data: responseData, 35520 status: request.status, 35521 statusText: request.statusText, 35522 headers: responseHeaders, 35523 config, 35524 request 35525 }; 35526 35527 (0,_core_settle_js__WEBPACK_IMPORTED_MODULE_2__["default"])(function _resolve(value) { 35528 resolve(value); 35529 done(); 35530 }, function _reject(err) { 35531 reject(err); 35532 done(); 35533 }, response); 35534 35535 // Clean up request 35536 request = null; 35537 } 35538 35539 if ('onloadend' in request) { 35540 // Use onloadend if available 35541 request.onloadend = onloadend; 35542 } else { 35543 // Listen for ready state to emulate onloadend 35544 request.onreadystatechange = function handleLoad() { 35545 if (!request || request.readyState !== 4) { 35546 return; 35547 } 35548 35549 // The request errored out and we didn't get a response, this will be 35550 // handled by onerror instead 35551 // With one exception: request that using file: protocol, most browsers 35552 // will return status as 0 even though it's a successful request 35553 if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) { 35554 return; 35555 } 35556 // readystate handler is calling before onerror or ontimeout handlers, 35557 // so we should call onloadend on the next 'tick' 35558 setTimeout(onloadend); 35559 }; 35560 } 35561 35562 // Handle browser request cancellation (as opposed to a manual cancellation) 35563 request.onabort = function handleAbort() { 35564 if (!request) { 35565 return; 35566 } 35567 35568 reject(new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"]('Request aborted', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"].ECONNABORTED, config, request)); 35569 35570 // Clean up request 35571 request = null; 35572 }; 35573 35574 // Handle low level network errors 35575 request.onerror = function handleError() { 35576 // Real errors are hidden from us by the browser 35577 // onerror should only fire if it's a network error 35578 reject(new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"]('Network Error', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"].ERR_NETWORK, config, request)); 35579 35580 // Clean up request 35581 request = null; 35582 }; 35583 35584 // Handle timeout 35585 request.ontimeout = function handleTimeout() { 35586 let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded'; 35587 const transitional = _config.transitional || _defaults_transitional_js__WEBPACK_IMPORTED_MODULE_4__["default"]; 35588 if (_config.timeoutErrorMessage) { 35589 timeoutErrorMessage = _config.timeoutErrorMessage; 35590 } 35591 reject(new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"]( 35592 timeoutErrorMessage, 35593 transitional.clarifyTimeoutError ? _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"].ETIMEDOUT : _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"].ECONNABORTED, 35594 config, 35595 request)); 35596 35597 // Clean up request 35598 request = null; 35599 }; 35600 35601 // Remove Content-Type if data is undefined 35602 requestData === undefined && requestHeaders.setContentType(null); 35603 35604 // Add headers to the request 35605 if ('setRequestHeader' in request) { 35606 _utils_js__WEBPACK_IMPORTED_MODULE_5__["default"].forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) { 35607 request.setRequestHeader(key, val); 35608 }); 35609 } 35610 35611 // Add withCredentials to request if needed 35612 if (!_utils_js__WEBPACK_IMPORTED_MODULE_5__["default"].isUndefined(_config.withCredentials)) { 35613 request.withCredentials = !!_config.withCredentials; 35614 } 35615 35616 // Add responseType to request if needed 35617 if (responseType && responseType !== 'json') { 35618 request.responseType = _config.responseType; 35619 } 35620 35621 // Handle progress if needed 35622 if (onDownloadProgress) { 35623 ([downloadThrottled, flushDownload] = (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_6__.progressEventReducer)(onDownloadProgress, true)); 35624 request.addEventListener('progress', downloadThrottled); 35625 } 35626 35627 // Not all browsers support upload events 35628 if (onUploadProgress && request.upload) { 35629 ([uploadThrottled, flushUpload] = (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_6__.progressEventReducer)(onUploadProgress)); 35630 35631 request.upload.addEventListener('progress', uploadThrottled); 35632 35633 request.upload.addEventListener('loadend', flushUpload); 35634 } 35635 35636 if (_config.cancelToken || _config.signal) { 35637 // Handle cancellation 35638 // eslint-disable-next-line func-names 35639 onCanceled = cancel => { 35640 if (!request) { 35641 return; 35642 } 35643 reject(!cancel || cancel.type ? new _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_7__["default"](null, config, request) : cancel); 35644 request.abort(); 35645 request = null; 35646 }; 35647 35648 _config.cancelToken && _config.cancelToken.subscribe(onCanceled); 35649 if (_config.signal) { 35650 _config.signal.aborted ? onCanceled() : _config.signal.addEventListener('abort', onCanceled); 35651 } 35652 } 35653 35654 const protocol = (0,_helpers_parseProtocol_js__WEBPACK_IMPORTED_MODULE_8__["default"])(_config.url); 35655 35656 if (protocol && _platform_index_js__WEBPACK_IMPORTED_MODULE_9__["default"].protocols.indexOf(protocol) === -1) { 35657 reject(new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"]('Unsupported protocol ' + protocol + ':', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"].ERR_BAD_REQUEST, config)); 35658 return; 35659 } 35660 35661 35662 // Send the request 35663 request.send(requestData || null); 35664 }); 35665}); 35666 35667 35668/***/ }), 35669
vendor: 6,423 bytes, lines 35670-35790
35670/***/ "./node_modules/axios/lib/axios.js": 35671/*!*****************************************!*\ 35672 !*** ./node_modules/axios/lib/axios.js ***! 35673 \*****************************************/ 35674/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 35675 35676"use strict"; 35677__webpack_require__.r(__webpack_exports__); 35678/* harmony export */ __webpack_require__.d(__webpack_exports__, { 35679/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 35680/* harmony export */ }); 35681/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils.js */ "./node_modules/axios/lib/utils.js"); 35682/* harmony import */ var _helpers_bind_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./helpers/bind.js */ "./node_modules/axios/lib/helpers/bind.js"); 35683/* harmony import */ var _core_Axios_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./core/Axios.js */ "./node_modules/axios/lib/core/Axios.js"); 35684/* harmony import */ var _core_mergeConfig_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./core/mergeConfig.js */ "./node_modules/axios/lib/core/mergeConfig.js"); 35685/* harmony import */ var _defaults_index_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./defaults/index.js */ "./node_modules/axios/lib/defaults/index.js"); 35686/* harmony import */ var _helpers_formDataToJSON_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./helpers/formDataToJSON.js */ "./node_modules/axios/lib/helpers/formDataToJSON.js"); 35687/* harmony import */ var _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./cancel/CanceledError.js */ "./node_modules/axios/lib/cancel/CanceledError.js"); 35688/* harmony import */ var _cancel_CancelToken_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./cancel/CancelToken.js */ "./node_modules/axios/lib/cancel/CancelToken.js"); 35689/* harmony import */ var _cancel_isCancel_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./cancel/isCancel.js */ "./node_modules/axios/lib/cancel/isCancel.js"); 35690/* harmony import */ var _env_data_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./env/data.js */ "./node_modules/axios/lib/env/data.js"); 35691/* harmony import */ var _helpers_toFormData_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./helpers/toFormData.js */ "./node_modules/axios/lib/helpers/toFormData.js"); 35692/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js"); 35693/* harmony import */ var _helpers_spread_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./helpers/spread.js */ "./node_modules/axios/lib/helpers/spread.js"); 35694/* harmony import */ var _helpers_isAxiosError_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./helpers/isAxiosError.js */ "./node_modules/axios/lib/helpers/isAxiosError.js"); 35695/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js"); 35696/* harmony import */ var _adapters_adapters_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./adapters/adapters.js */ "./node_modules/axios/lib/adapters/adapters.js"); 35697/* harmony import */ var _helpers_HttpStatusCode_js__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./helpers/HttpStatusCode.js */ "./node_modules/axios/lib/helpers/HttpStatusCode.js"); 35698 35699 35700 35701 35702 35703 35704 35705 35706 35707 35708 35709 35710 35711 35712 35713 35714 35715 35716 35717 35718/** 35719 * Create an instance of Axios 35720 * 35721 * @param {Object} defaultConfig The default config for the instance 35722 * 35723 * @returns {Axios} A new instance of Axios 35724 */ 35725function createInstance(defaultConfig) { 35726 const context = new _core_Axios_js__WEBPACK_IMPORTED_MODULE_0__["default"](defaultConfig); 35727 const instance = (0,_helpers_bind_js__WEBPACK_IMPORTED_MODULE_1__["default"])(_core_Axios_js__WEBPACK_IMPORTED_MODULE_0__["default"].prototype.request, context); 35728 35729 // Copy axios.prototype to instance 35730 _utils_js__WEBPACK_IMPORTED_MODULE_2__["default"].extend(instance, _core_Axios_js__WEBPACK_IMPORTED_MODULE_0__["default"].prototype, context, {allOwnKeys: true}); 35731 35732 // Copy context to instance 35733 _utils_js__WEBPACK_IMPORTED_MODULE_2__["default"].extend(instance, context, null, {allOwnKeys: true}); 35734 35735 // Factory for creating new instances 35736 instance.create = function create(instanceConfig) { 35737 return createInstance((0,_core_mergeConfig_js__WEBPACK_IMPORTED_MODULE_3__["default"])(defaultConfig, instanceConfig)); 35738 }; 35739 35740 return instance; 35741} 35742 35743// Create the default instance to be exported 35744const axios = createInstance(_defaults_index_js__WEBPACK_IMPORTED_MODULE_4__["default"]); 35745 35746// Expose Axios class to allow class inheritance 35747axios.Axios = _core_Axios_js__WEBPACK_IMPORTED_MODULE_0__["default"]; 35748 35749// Expose Cancel & CancelToken 35750axios.CanceledError = _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_5__["default"]; 35751axios.CancelToken = _cancel_CancelToken_js__WEBPACK_IMPORTED_MODULE_6__["default"]; 35752axios.isCancel = _cancel_isCancel_js__WEBPACK_IMPORTED_MODULE_7__["default"]; 35753axios.VERSION = _env_data_js__WEBPACK_IMPORTED_MODULE_8__.VERSION; 35754axios.toFormData = _helpers_toFormData_js__WEBPACK_IMPORTED_MODULE_9__["default"]; 35755 35756// Expose AxiosError class 35757axios.AxiosError = _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_10__["default"]; 35758 35759// alias for CanceledError for backward compatibility 35760axios.Cancel = axios.CanceledError; 35761 35762// Expose all/spread 35763axios.all = function all(promises) { 35764 return Promise.all(promises); 35765}; 35766 35767axios.spread = _helpers_spread_js__WEBPACK_IMPORTED_MODULE_11__["default"]; 35768 35769// Expose isAxiosError 35770axios.isAxiosError = _helpers_isAxiosError_js__WEBPACK_IMPORTED_MODULE_12__["default"]; 35771 35772// Expose mergeConfig 35773axios.mergeConfig = _core_mergeConfig_js__WEBPACK_IMPORTED_MODULE_3__["default"]; 35774 35775axios.AxiosHeaders = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_13__["default"]; 35776 35777axios.formToJSON = thing => (0,_helpers_formDataToJSON_js__WEBPACK_IMPORTED_MODULE_14__["default"])(_utils_js__WEBPACK_IMPORTED_MODULE_2__["default"].isHTMLForm(thing) ? new FormData(thing) : thing); 35778 35779axios.getAdapter = _adapters_adapters_js__WEBPACK_IMPORTED_MODULE_15__["default"].getAdapter; 35780 35781axios.HttpStatusCode = _helpers_HttpStatusCode_js__WEBPACK_IMPORTED_MODULE_16__["default"]; 35782 35783axios.default = axios; 35784 35785// this module should only have a default export 35786/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (axios); 35787 35788 35789/***/ }), 35790
vendor: 3,556 bytes, lines 35791-35941
35791/***/ "./node_modules/axios/lib/cancel/CancelToken.js": 35792/*!******************************************************!*\ 35793 !*** ./node_modules/axios/lib/cancel/CancelToken.js ***! 35794 \******************************************************/ 35795/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 35796 35797"use strict"; 35798__webpack_require__.r(__webpack_exports__); 35799/* harmony export */ __webpack_require__.d(__webpack_exports__, { 35800/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 35801/* harmony export */ }); 35802/* harmony import */ var _CanceledError_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./CanceledError.js */ "./node_modules/axios/lib/cancel/CanceledError.js"); 35803 35804 35805 35806 35807/** 35808 * A `CancelToken` is an object that can be used to request cancellation of an operation. 35809 * 35810 * @param {Function} executor The executor function. 35811 * 35812 * @returns {CancelToken} 35813 */ 35814class CancelToken { 35815 constructor(executor) { 35816 if (typeof executor !== 'function') { 35817 throw new TypeError('executor must be a function.'); 35818 } 35819 35820 let resolvePromise; 35821 35822 this.promise = new Promise(function promiseExecutor(resolve) { 35823 resolvePromise = resolve; 35824 }); 35825 35826 const token = this; 35827 35828 // eslint-disable-next-line func-names 35829 this.promise.then(cancel => { 35830 if (!token._listeners) return; 35831 35832 let i = token._listeners.length; 35833 35834 while (i-- > 0) { 35835 token._listeners[i](cancel); 35836 } 35837 token._listeners = null; 35838 }); 35839 35840 // eslint-disable-next-line func-names 35841 this.promise.then = onfulfilled => { 35842 let _resolve; 35843 // eslint-disable-next-line func-names 35844 const promise = new Promise(resolve => { 35845 token.subscribe(resolve); 35846 _resolve = resolve; 35847 }).then(onfulfilled); 35848 35849 promise.cancel = function reject() { 35850 token.unsubscribe(_resolve); 35851 }; 35852 35853 return promise; 35854 }; 35855 35856 executor(function cancel(message, config, request) { 35857 if (token.reason) { 35858 // Cancellation has already been requested 35859 return; 35860 } 35861 35862 token.reason = new _CanceledError_js__WEBPACK_IMPORTED_MODULE_0__["default"](message, config, request); 35863 resolvePromise(token.reason); 35864 }); 35865 } 35866 35867 /** 35868 * Throws a `CanceledError` if cancellation has been requested. 35869 */ 35870 throwIfRequested() { 35871 if (this.reason) { 35872 throw this.reason; 35873 } 35874 } 35875 35876 /** 35877 * Subscribe to the cancel signal 35878 */ 35879 35880 subscribe(listener) { 35881 if (this.reason) { 35882 listener(this.reason); 35883 return; 35884 } 35885 35886 if (this._listeners) { 35887 this._listeners.push(listener); 35888 } else { 35889 this._listeners = [listener]; 35890 } 35891 } 35892 35893 /** 35894 * Unsubscribe from the cancel signal 35895 */ 35896 35897 unsubscribe(listener) { 35898 if (!this._listeners) { 35899 return; 35900 } 35901 const index = this._listeners.indexOf(listener); 35902 if (index !== -1) { 35903 this._listeners.splice(index, 1); 35904 } 35905 } 35906 35907 toAbortSignal() { 35908 const controller = new AbortController(); 35909 35910 const abort = (err) => { 35911 controller.abort(err); 35912 }; 35913 35914 this.subscribe(abort); 35915 35916 controller.signal.unsubscribe = () => this.unsubscribe(abort); 35917 35918 return controller.signal; 35919 } 35920 35921 /** 35922 * Returns an object that contains a new `CancelToken` and a function that, when called, 35923 * cancels the `CancelToken`. 35924 */ 35925 static source() { 35926 let cancel; 35927 const token = new CancelToken(function executor(c) { 35928 cancel = c; 35929 }); 35930 return { 35931 token, 35932 cancel 35933 }; 35934 } 35935} 35936 35937/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (CancelToken); 35938 35939 35940/***/ }), 35941
vendor: 1,730 bytes, lines 35942-35983
35942/***/ "./node_modules/axios/lib/cancel/CanceledError.js": 35943/*!********************************************************!*\ 35944 !*** ./node_modules/axios/lib/cancel/CanceledError.js ***! 35945 \********************************************************/ 35946/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 35947 35948"use strict"; 35949__webpack_require__.r(__webpack_exports__); 35950/* harmony export */ __webpack_require__.d(__webpack_exports__, { 35951/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 35952/* harmony export */ }); 35953/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js"); 35954/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 35955 35956 35957 35958 35959 35960/** 35961 * A `CanceledError` is an object that is thrown when an operation is canceled. 35962 * 35963 * @param {string=} message The message. 35964 * @param {Object=} config The config. 35965 * @param {Object=} request The request. 35966 * 35967 * @returns {CanceledError} The created error. 35968 */ 35969function CanceledError(message, config, request) { 35970 // eslint-disable-next-line no-eq-null,eqeqeq 35971 _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"].call(this, message == null ? 'canceled' : message, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"].ERR_CANCELED, config, request); 35972 this.name = 'CanceledError'; 35973} 35974 35975_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].inherits(CanceledError, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"], { 35976 __CANCEL__: true 35977}); 35978 35979/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (CanceledError); 35980 35981 35982/***/ }), 35983
vendor: 614 bytes, lines 35984-36003
35984/***/ "./node_modules/axios/lib/cancel/isCancel.js": 35985/*!***************************************************!*\ 35986 !*** ./node_modules/axios/lib/cancel/isCancel.js ***! 35987 \***************************************************/ 35988/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 35989 35990"use strict"; 35991__webpack_require__.r(__webpack_exports__); 35992/* harmony export */ __webpack_require__.d(__webpack_exports__, { 35993/* harmony export */ "default": () => (/* binding */ isCancel) 35994/* harmony export */ }); 35995 35996 35997function isCancel(value) { 35998 return !!(value && value.__CANCEL__); 35999} 36000 36001 36002/***/ }), 36003
vendor: 9,367 bytes, lines 36004-36268
36004/***/ "./node_modules/axios/lib/core/Axios.js": 36005/*!**********************************************!*\ 36006 !*** ./node_modules/axios/lib/core/Axios.js ***! 36007 \**********************************************/ 36008/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 36009 36010"use strict"; 36011__webpack_require__.r(__webpack_exports__); 36012/* harmony export */ __webpack_require__.d(__webpack_exports__, { 36013/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 36014/* harmony export */ }); 36015/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js"); 36016/* harmony import */ var _helpers_buildURL_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../helpers/buildURL.js */ "./node_modules/axios/lib/helpers/buildURL.js"); 36017/* harmony import */ var _InterceptorManager_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./InterceptorManager.js */ "./node_modules/axios/lib/core/InterceptorManager.js"); 36018/* harmony import */ var _dispatchRequest_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./dispatchRequest.js */ "./node_modules/axios/lib/core/dispatchRequest.js"); 36019/* harmony import */ var _mergeConfig_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./mergeConfig.js */ "./node_modules/axios/lib/core/mergeConfig.js"); 36020/* harmony import */ var _buildFullPath_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./buildFullPath.js */ "./node_modules/axios/lib/core/buildFullPath.js"); 36021/* harmony import */ var _helpers_validator_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../helpers/validator.js */ "./node_modules/axios/lib/helpers/validator.js"); 36022/* harmony import */ var _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js"); 36023 36024 36025 36026 36027 36028 36029 36030 36031 36032 36033 36034const validators = _helpers_validator_js__WEBPACK_IMPORTED_MODULE_0__["default"].validators; 36035 36036/** 36037 * Create a new instance of Axios 36038 * 36039 * @param {Object} instanceConfig The default config for the instance 36040 * 36041 * @return {Axios} A new instance of Axios 36042 */ 36043class Axios { 36044 constructor(instanceConfig) { 36045 this.defaults = instanceConfig; 36046 this.interceptors = { 36047 request: new _InterceptorManager_js__WEBPACK_IMPORTED_MODULE_1__["default"](), 36048 response: new _InterceptorManager_js__WEBPACK_IMPORTED_MODULE_1__["default"]() 36049 }; 36050 } 36051 36052 /** 36053 * Dispatch a request 36054 * 36055 * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults) 36056 * @param {?Object} config 36057 * 36058 * @returns {Promise} The Promise to be fulfilled 36059 */ 36060 async request(configOrUrl, config) { 36061 try { 36062 return await this._request(configOrUrl, config); 36063 } catch (err) { 36064 if (err instanceof Error) { 36065 let dummy = {}; 36066 36067 Error.captureStackTrace ? Error.captureStackTrace(dummy) : (dummy = new Error()); 36068 36069 // slice off the Error: ... line 36070 const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, '') : ''; 36071 try { 36072 if (!err.stack) { 36073 err.stack = stack; 36074 // match without the 2 top stack lines 36075 } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ''))) { 36076 err.stack += '\n' + stack 36077 } 36078 } catch (e) { 36079 // ignore the case where "stack" is an un-writable property 36080 } 36081 } 36082 36083 throw err; 36084 } 36085 } 36086 36087 _request(configOrUrl, config) { 36088 /*eslint no-param-reassign:0*/ 36089 // Allow for axios('example/url'[, config]) a la fetch API 36090 if (typeof configOrUrl === 'string') { 36091 config = config || {}; 36092 config.url = configOrUrl; 36093 } else { 36094 config = configOrUrl || {}; 36095 } 36096 36097 config = (0,_mergeConfig_js__WEBPACK_IMPORTED_MODULE_2__["default"])(this.defaults, config); 36098 36099 const {transitional, paramsSerializer, headers} = config; 36100 36101 if (transitional !== undefined) { 36102 _helpers_validator_js__WEBPACK_IMPORTED_MODULE_0__["default"].assertOptions(transitional, { 36103 silentJSONParsing: validators.transitional(validators.boolean), 36104 forcedJSONParsing: validators.transitional(validators.boolean), 36105 clarifyTimeoutError: validators.transitional(validators.boolean) 36106 }, false); 36107 } 36108 36109 if (paramsSerializer != null) { 36110 if (_utils_js__WEBPACK_IMPORTED_MODULE_3__["default"].isFunction(paramsSerializer)) { 36111 config.paramsSerializer = { 36112 serialize: paramsSerializer 36113 } 36114 } else { 36115 _helpers_validator_js__WEBPACK_IMPORTED_MODULE_0__["default"].assertOptions(paramsSerializer, { 36116 encode: validators.function, 36117 serialize: validators.function 36118 }, true); 36119 } 36120 } 36121 36122 // Set config.allowAbsoluteUrls 36123 if (config.allowAbsoluteUrls !== undefined) { 36124 // do nothing 36125 } else if (this.defaults.allowAbsoluteUrls !== undefined) { 36126 config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls; 36127 } else { 36128 config.allowAbsoluteUrls = true; 36129 } 36130 36131 _helpers_validator_js__WEBPACK_IMPORTED_MODULE_0__["default"].assertOptions(config, { 36132 baseUrl: validators.spelling('baseURL'), 36133 withXsrfToken: validators.spelling('withXSRFToken') 36134 }, true); 36135 36136 // Set config.method 36137 config.method = (config.method || this.defaults.method || 'get').toLowerCase(); 36138 36139 // Flatten headers 36140 let contextHeaders = headers && _utils_js__WEBPACK_IMPORTED_MODULE_3__["default"].merge( 36141 headers.common, 36142 headers[config.method] 36143 ); 36144 36145 headers && _utils_js__WEBPACK_IMPORTED_MODULE_3__["default"].forEach( 36146 ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], 36147 (method) => { 36148 delete headers[method]; 36149 } 36150 ); 36151 36152 config.headers = _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_4__["default"].concat(contextHeaders, headers); 36153 36154 // filter out skipped interceptors 36155 const requestInterceptorChain = []; 36156 let synchronousRequestInterceptors = true; 36157 this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { 36158 if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) { 36159 return; 36160 } 36161 36162 synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous; 36163 36164 requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected); 36165 }); 36166 36167 const responseInterceptorChain = []; 36168 this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { 36169 responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected); 36170 }); 36171 36172 let promise; 36173 let i = 0; 36174 let len; 36175 36176 if (!synchronousRequestInterceptors) { 36177 const chain = [_dispatchRequest_js__WEBPACK_IMPORTED_MODULE_5__["default"].bind(this), undefined]; 36178 chain.unshift.apply(chain, requestInterceptorChain); 36179 chain.push.apply(chain, responseInterceptorChain); 36180 len = chain.length; 36181 36182 promise = Promise.resolve(config); 36183 36184 while (i < len) { 36185 promise = promise.then(chain[i++], chain[i++]); 36186 } 36187 36188 return promise; 36189 } 36190 36191 len = requestInterceptorChain.length; 36192 36193 let newConfig = config; 36194 36195 i = 0; 36196 36197 while (i < len) { 36198 const onFulfilled = requestInterceptorChain[i++]; 36199 const onRejected = requestInterceptorChain[i++]; 36200 try { 36201 newConfig = onFulfilled(newConfig); 36202 } catch (error) { 36203 onRejected.call(this, error); 36204 break; 36205 } 36206 } 36207 36208 try { 36209 promise = _dispatchRequest_js__WEBPACK_IMPORTED_MODULE_5__["default"].call(this, newConfig); 36210 } catch (error) { 36211 return Promise.reject(error); 36212 } 36213 36214 i = 0; 36215 len = responseInterceptorChain.length; 36216 36217 while (i < len) { 36218 promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]); 36219 } 36220 36221 return promise; 36222 } 36223 36224 getUri(config) { 36225 config = (0,_mergeConfig_js__WEBPACK_IMPORTED_MODULE_2__["default"])(this.defaults, config); 36226 const fullPath = (0,_buildFullPath_js__WEBPACK_IMPORTED_MODULE_6__["default"])(config.baseURL, config.url, config.allowAbsoluteUrls); 36227 return (0,_helpers_buildURL_js__WEBPACK_IMPORTED_MODULE_7__["default"])(fullPath, config.params, config.paramsSerializer); 36228 } 36229} 36230 36231// Provide aliases for supported request methods 36232_utils_js__WEBPACK_IMPORTED_MODULE_3__["default"].forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) { 36233 /*eslint func-names:0*/ 36234 Axios.prototype[method] = function(url, config) { 36235 return this.request((0,_mergeConfig_js__WEBPACK_IMPORTED_MODULE_2__["default"])(config || {}, { 36236 method, 36237 url, 36238 data: (config || {}).data 36239 })); 36240 }; 36241}); 36242 36243_utils_js__WEBPACK_IMPORTED_MODULE_3__["default"].forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { 36244 /*eslint func-names:0*/ 36245 36246 function generateHTTPMethod(isForm) { 36247 return function httpMethod(url, data, config) { 36248 return this.request((0,_mergeConfig_js__WEBPACK_IMPORTED_MODULE_2__["default"])(config || {}, { 36249 method, 36250 headers: isForm ? { 36251 'Content-Type': 'multipart/form-data' 36252 } : {}, 36253 url, 36254 data 36255 })); 36256 }; 36257 } 36258 36259 Axios.prototype[method] = generateHTTPMethod(); 36260 36261 Axios.prototype[method + 'Form'] = generateHTTPMethod(true); 36262}); 36263 36264/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Axios); 36265 36266 36267/***/ }), 36268
vendor: 3,374 bytes, lines 36269-36387
36269/***/ "./node_modules/axios/lib/core/AxiosError.js": 36270/*!***************************************************!*\ 36271 !*** ./node_modules/axios/lib/core/AxiosError.js ***! 36272 \***************************************************/ 36273/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 36274 36275"use strict"; 36276__webpack_require__.r(__webpack_exports__); 36277/* harmony export */ __webpack_require__.d(__webpack_exports__, { 36278/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 36279/* harmony export */ }); 36280/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 36281 36282 36283 36284 36285/** 36286 * Create an Error with the specified message, config, error code, request and response. 36287 * 36288 * @param {string} message The error message. 36289 * @param {string} [code] The error code (for example, 'ECONNABORTED'). 36290 * @param {Object} [config] The config. 36291 * @param {Object} [request] The request. 36292 * @param {Object} [response] The response. 36293 * 36294 * @returns {Error} The created error. 36295 */ 36296function AxiosError(message, code, config, request, response) { 36297 Error.call(this); 36298 36299 if (Error.captureStackTrace) { 36300 Error.captureStackTrace(this, this.constructor); 36301 } else { 36302 this.stack = (new Error()).stack; 36303 } 36304 36305 this.message = message; 36306 this.name = 'AxiosError'; 36307 code && (this.code = code); 36308 config && (this.config = config); 36309 request && (this.request = request); 36310 if (response) { 36311 this.response = response; 36312 this.status = response.status ? response.status : null; 36313 } 36314} 36315 36316_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].inherits(AxiosError, Error, { 36317 toJSON: function toJSON() { 36318 return { 36319 // Standard 36320 message: this.message, 36321 name: this.name, 36322 // Microsoft 36323 description: this.description, 36324 number: this.number, 36325 // Mozilla 36326 fileName: this.fileName, 36327 lineNumber: this.lineNumber, 36328 columnNumber: this.columnNumber, 36329 stack: this.stack, 36330 // Axios 36331 config: _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toJSONObject(this.config), 36332 code: this.code, 36333 status: this.status 36334 }; 36335 } 36336}); 36337 36338const prototype = AxiosError.prototype; 36339const descriptors = {}; 36340 36341[ 36342 'ERR_BAD_OPTION_VALUE', 36343 'ERR_BAD_OPTION', 36344 'ECONNABORTED', 36345 'ETIMEDOUT', 36346 'ERR_NETWORK', 36347 'ERR_FR_TOO_MANY_REDIRECTS', 36348 'ERR_DEPRECATED', 36349 'ERR_BAD_RESPONSE', 36350 'ERR_BAD_REQUEST', 36351 'ERR_CANCELED', 36352 'ERR_NOT_SUPPORT', 36353 'ERR_INVALID_URL' 36354// eslint-disable-next-line func-names 36355].forEach(code => { 36356 descriptors[code] = {value: code}; 36357}); 36358 36359Object.defineProperties(AxiosError, descriptors); 36360Object.defineProperty(prototype, 'isAxiosError', {value: true}); 36361 36362// eslint-disable-next-line func-names 36363AxiosError.from = (error, code, config, request, response, customProps) => { 36364 const axiosError = Object.create(prototype); 36365 36366 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toFlatObject(error, axiosError, function filter(obj) { 36367 return obj !== Error.prototype; 36368 }, prop => { 36369 return prop !== 'isAxiosError'; 36370 }); 36371 36372 AxiosError.call(axiosError, error.message, code, config, request, response); 36373 36374 axiosError.cause = error; 36375 36376 axiosError.name = error.name; 36377 36378 customProps && Object.assign(axiosError, customProps); 36379 36380 return axiosError; 36381}; 36382 36383/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (AxiosError); 36384 36385 36386/***/ }), 36387
vendor: 8,982 bytes, lines 36388-36706
36388/***/ "./node_modules/axios/lib/core/AxiosHeaders.js": 36389/*!*****************************************************!*\ 36390 !*** ./node_modules/axios/lib/core/AxiosHeaders.js ***! 36391 \*****************************************************/ 36392/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 36393 36394"use strict"; 36395__webpack_require__.r(__webpack_exports__); 36396/* harmony export */ __webpack_require__.d(__webpack_exports__, { 36397/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 36398/* harmony export */ }); 36399/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 36400/* harmony import */ var _helpers_parseHeaders_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../helpers/parseHeaders.js */ "./node_modules/axios/lib/helpers/parseHeaders.js"); 36401 36402 36403 36404 36405 36406const $internals = Symbol('internals'); 36407 36408function normalizeHeader(header) { 36409 return header && String(header).trim().toLowerCase(); 36410} 36411 36412function normalizeValue(value) { 36413 if (value === false || value == null) { 36414 return value; 36415 } 36416 36417 return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(value) ? value.map(normalizeValue) : String(value); 36418} 36419 36420function parseTokens(str) { 36421 const tokens = Object.create(null); 36422 const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g; 36423 let match; 36424 36425 while ((match = tokensRE.exec(str))) { 36426 tokens[match[1]] = match[2]; 36427 } 36428 36429 return tokens; 36430} 36431 36432const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim()); 36433 36434function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) { 36435 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(filter)) { 36436 return filter.call(this, value, header); 36437 } 36438 36439 if (isHeaderNameFilter) { 36440 value = header; 36441 } 36442 36443 if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(value)) return; 36444 36445 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(filter)) { 36446 return value.indexOf(filter) !== -1; 36447 } 36448 36449 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isRegExp(filter)) { 36450 return filter.test(value); 36451 } 36452} 36453 36454function formatHeader(header) { 36455 return header.trim() 36456 .toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => { 36457 return char.toUpperCase() + str; 36458 }); 36459} 36460 36461function buildAccessors(obj, header) { 36462 const accessorName = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toCamelCase(' ' + header); 36463 36464 ['get', 'set', 'has'].forEach(methodName => { 36465 Object.defineProperty(obj, methodName + accessorName, { 36466 value: function(arg1, arg2, arg3) { 36467 return this[methodName].call(this, header, arg1, arg2, arg3); 36468 }, 36469 configurable: true 36470 }); 36471 }); 36472} 36473 36474class AxiosHeaders { 36475 constructor(headers) { 36476 headers && this.set(headers); 36477 } 36478 36479 set(header, valueOrRewrite, rewrite) { 36480 const self = this; 36481 36482 function setHeader(_value, _header, _rewrite) { 36483 const lHeader = normalizeHeader(_header); 36484 36485 if (!lHeader) { 36486 throw new Error('header name must be a non-empty string'); 36487 } 36488 36489 const key = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].findKey(self, lHeader); 36490 36491 if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) { 36492 self[key || _header] = normalizeValue(_value); 36493 } 36494 } 36495 36496 const setHeaders = (headers, _rewrite) => 36497 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite)); 36498 36499 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isPlainObject(header) || header instanceof this.constructor) { 36500 setHeaders(header, valueOrRewrite) 36501 } else if(_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(header) && (header = header.trim()) && !isValidHeaderName(header)) { 36502 setHeaders((0,_helpers_parseHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"])(header), valueOrRewrite); 36503 } else if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isHeaders(header)) { 36504 for (const [key, value] of header.entries()) { 36505 setHeader(value, key, rewrite); 36506 } 36507 } else { 36508 header != null && setHeader(valueOrRewrite, header, rewrite); 36509 } 36510 36511 return this; 36512 } 36513 36514 get(header, parser) { 36515 header = normalizeHeader(header); 36516 36517 if (header) { 36518 const key = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].findKey(this, header); 36519 36520 if (key) { 36521 const value = this[key]; 36522 36523 if (!parser) { 36524 return value; 36525 } 36526 36527 if (parser === true) { 36528 return parseTokens(value); 36529 } 36530 36531 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(parser)) { 36532 return parser.call(this, value, key); 36533 } 36534 36535 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isRegExp(parser)) { 36536 return parser.exec(value); 36537 } 36538 36539 throw new TypeError('parser must be boolean|regexp|function'); 36540 } 36541 } 36542 } 36543 36544 has(header, matcher) { 36545 header = normalizeHeader(header); 36546 36547 if (header) { 36548 const key = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].findKey(this, header); 36549 36550 return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher))); 36551 } 36552 36553 return false; 36554 } 36555 36556 delete(header, matcher) { 36557 const self = this; 36558 let deleted = false; 36559 36560 function deleteHeader(_header) { 36561 _header = normalizeHeader(_header); 36562 36563 if (_header) { 36564 const key = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].findKey(self, _header); 36565 36566 if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) { 36567 delete self[key]; 36568 36569 deleted = true; 36570 } 36571 } 36572 } 36573 36574 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(header)) { 36575 header.forEach(deleteHeader); 36576 } else { 36577 deleteHeader(header); 36578 } 36579 36580 return deleted; 36581 } 36582 36583 clear(matcher) { 36584 const keys = Object.keys(this); 36585 let i = keys.length; 36586 let deleted = false; 36587 36588 while (i--) { 36589 const key = keys[i]; 36590 if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) { 36591 delete this[key]; 36592 deleted = true; 36593 } 36594 } 36595 36596 return deleted; 36597 } 36598 36599 normalize(format) { 36600 const self = this; 36601 const headers = {}; 36602 36603 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(this, (value, header) => { 36604 const key = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].findKey(headers, header); 36605 36606 if (key) { 36607 self[key] = normalizeValue(value); 36608 delete self[header]; 36609 return; 36610 } 36611 36612 const normalized = format ? formatHeader(header) : String(header).trim(); 36613 36614 if (normalized !== header) { 36615 delete self[header]; 36616 } 36617 36618 self[normalized] = normalizeValue(value); 36619 36620 headers[normalized] = true; 36621 }); 36622 36623 return this; 36624 } 36625 36626 concat(...targets) { 36627 return this.constructor.concat(this, ...targets); 36628 } 36629 36630 toJSON(asStrings) { 36631 const obj = Object.create(null); 36632 36633 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(this, (value, header) => { 36634 value != null && value !== false && (obj[header] = asStrings && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(value) ? value.join(', ') : value); 36635 }); 36636 36637 return obj; 36638 } 36639 36640 [Symbol.iterator]() { 36641 return Object.entries(this.toJSON())[Symbol.iterator](); 36642 } 36643 36644 toString() { 36645 return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\n'); 36646 } 36647 36648 get [Symbol.toStringTag]() { 36649 return 'AxiosHeaders'; 36650 } 36651 36652 static from(thing) { 36653 return thing instanceof this ? thing : new this(thing); 36654 } 36655 36656 static concat(first, ...targets) { 36657 const computed = new this(first); 36658 36659 targets.forEach((target) => computed.set(target)); 36660 36661 return computed; 36662 } 36663 36664 static accessor(header) { 36665 const internals = this[$internals] = (this[$internals] = { 36666 accessors: {} 36667 }); 36668 36669 const accessors = internals.accessors; 36670 const prototype = this.prototype; 36671 36672 function defineAccessor(_header) { 36673 const lHeader = normalizeHeader(_header); 36674 36675 if (!accessors[lHeader]) { 36676 buildAccessors(prototype, _header); 36677 accessors[lHeader] = true; 36678 } 36679 } 36680 36681 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header); 36682 36683 return this; 36684 } 36685} 36686 36687AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']); 36688 36689// reserved names hotfix 36690_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => { 36691 let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set` 36692 return { 36693 get: () => value, 36694 set(headerValue) { 36695 this[mapped] = headerValue; 36696 } 36697 } 36698}); 36699 36700_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].freezeMethods(AxiosHeaders); 36701 36702/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (AxiosHeaders); 36703 36704 36705/***/ }), 36706
vendor: 2,341 bytes, lines 36707-36793
36707/***/ "./node_modules/axios/lib/core/InterceptorManager.js": 36708/*!***********************************************************!*\ 36709 !*** ./node_modules/axios/lib/core/InterceptorManager.js ***! 36710 \***********************************************************/ 36711/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 36712 36713"use strict"; 36714__webpack_require__.r(__webpack_exports__); 36715/* harmony export */ __webpack_require__.d(__webpack_exports__, { 36716/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 36717/* harmony export */ }); 36718/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js"); 36719 36720 36721 36722 36723class InterceptorManager { 36724 constructor() { 36725 this.handlers = []; 36726 } 36727 36728 /** 36729 * Add a new interceptor to the stack 36730 * 36731 * @param {Function} fulfilled The function to handle `then` for a `Promise` 36732 * @param {Function} rejected The function to handle `reject` for a `Promise` 36733 * 36734 * @return {Number} An ID used to remove interceptor later 36735 */ 36736 use(fulfilled, rejected, options) { 36737 this.handlers.push({ 36738 fulfilled, 36739 rejected, 36740 synchronous: options ? options.synchronous : false, 36741 runWhen: options ? options.runWhen : null 36742 }); 36743 return this.handlers.length - 1; 36744 } 36745 36746 /** 36747 * Remove an interceptor from the stack 36748 * 36749 * @param {Number} id The ID that was returned by `use` 36750 * 36751 * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise 36752 */ 36753 eject(id) { 36754 if (this.handlers[id]) { 36755 this.handlers[id] = null; 36756 } 36757 } 36758 36759 /** 36760 * Clear all interceptors from the stack 36761 * 36762 * @returns {void} 36763 */ 36764 clear() { 36765 if (this.handlers) { 36766 this.handlers = []; 36767 } 36768 } 36769 36770 /** 36771 * Iterate over all the registered interceptors 36772 * 36773 * This method is particularly useful for skipping over any 36774 * interceptors that may have become `null` calling `eject`. 36775 * 36776 * @param {Function} fn The function to call for each interceptor 36777 * 36778 * @returns {void} 36779 */ 36780 forEach(fn) { 36781 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(this.handlers, function forEachHandler(h) { 36782 if (h !== null) { 36783 fn(h); 36784 } 36785 }); 36786 } 36787} 36788 36789/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (InterceptorManager); 36790 36791 36792/***/ }), 36793
vendor: 1,695 bytes, lines 36794-36832
36794/***/ "./node_modules/axios/lib/core/buildFullPath.js": 36795/*!******************************************************!*\ 36796 !*** ./node_modules/axios/lib/core/buildFullPath.js ***! 36797 \******************************************************/ 36798/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 36799 36800"use strict"; 36801__webpack_require__.r(__webpack_exports__); 36802/* harmony export */ __webpack_require__.d(__webpack_exports__, { 36803/* harmony export */ "default": () => (/* binding */ buildFullPath) 36804/* harmony export */ }); 36805/* harmony import */ var _helpers_isAbsoluteURL_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../helpers/isAbsoluteURL.js */ "./node_modules/axios/lib/helpers/isAbsoluteURL.js"); 36806/* harmony import */ var _helpers_combineURLs_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../helpers/combineURLs.js */ "./node_modules/axios/lib/helpers/combineURLs.js"); 36807 36808 36809 36810 36811 36812/** 36813 * Creates a new URL by combining the baseURL with the requestedURL, 36814 * only when the requestedURL is not already an absolute URL. 36815 * If the requestURL is absolute, this function returns the requestedURL untouched. 36816 * 36817 * @param {string} baseURL The base URL 36818 * @param {string} requestedURL Absolute or relative URL to combine 36819 * 36820 * @returns {string} The combined full path 36821 */ 36822function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) { 36823 let isRelativeUrl = !(0,_helpers_isAbsoluteURL_js__WEBPACK_IMPORTED_MODULE_0__["default"])(requestedURL); 36824 if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) { 36825 return (0,_helpers_combineURLs_js__WEBPACK_IMPORTED_MODULE_1__["default"])(baseURL, requestedURL); 36826 } 36827 return requestedURL; 36828} 36829 36830 36831/***/ }), 36832
vendor: 3,988 bytes, lines 36833-36934
36833/***/ "./node_modules/axios/lib/core/dispatchRequest.js": 36834/*!********************************************************!*\ 36835 !*** ./node_modules/axios/lib/core/dispatchRequest.js ***! 36836 \********************************************************/ 36837/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 36838 36839"use strict"; 36840__webpack_require__.r(__webpack_exports__); 36841/* harmony export */ __webpack_require__.d(__webpack_exports__, { 36842/* harmony export */ "default": () => (/* binding */ dispatchRequest) 36843/* harmony export */ }); 36844/* harmony import */ var _transformData_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./transformData.js */ "./node_modules/axios/lib/core/transformData.js"); 36845/* harmony import */ var _cancel_isCancel_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../cancel/isCancel.js */ "./node_modules/axios/lib/cancel/isCancel.js"); 36846/* harmony import */ var _defaults_index_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../defaults/index.js */ "./node_modules/axios/lib/defaults/index.js"); 36847/* harmony import */ var _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../cancel/CanceledError.js */ "./node_modules/axios/lib/cancel/CanceledError.js"); 36848/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js"); 36849/* harmony import */ var _adapters_adapters_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../adapters/adapters.js */ "./node_modules/axios/lib/adapters/adapters.js"); 36850 36851 36852 36853 36854 36855 36856 36857 36858 36859/** 36860 * Throws a `CanceledError` if cancellation has been requested. 36861 * 36862 * @param {Object} config The config that is to be used for the request 36863 * 36864 * @returns {void} 36865 */ 36866function throwIfCancellationRequested(config) { 36867 if (config.cancelToken) { 36868 config.cancelToken.throwIfRequested(); 36869 } 36870 36871 if (config.signal && config.signal.aborted) { 36872 throw new _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_0__["default"](null, config); 36873 } 36874} 36875 36876/** 36877 * Dispatch a request to the server using the configured adapter. 36878 * 36879 * @param {object} config The config that is to be used for the request 36880 * 36881 * @returns {Promise} The Promise to be fulfilled 36882 */ 36883function dispatchRequest(config) { 36884 throwIfCancellationRequested(config); 36885 36886 config.headers = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"].from(config.headers); 36887 36888 // Transform request data 36889 config.data = _transformData_js__WEBPACK_IMPORTED_MODULE_2__["default"].call( 36890 config, 36891 config.transformRequest 36892 ); 36893 36894 if (['post', 'put', 'patch'].indexOf(config.method) !== -1) { 36895 config.headers.setContentType('application/x-www-form-urlencoded', false); 36896 } 36897 36898 const adapter = _adapters_adapters_js__WEBPACK_IMPORTED_MODULE_3__["default"].getAdapter(config.adapter || _defaults_index_js__WEBPACK_IMPORTED_MODULE_4__["default"].adapter); 36899 36900 return adapter(config).then(function onAdapterResolution(response) { 36901 throwIfCancellationRequested(config); 36902 36903 // Transform response data 36904 response.data = _transformData_js__WEBPACK_IMPORTED_MODULE_2__["default"].call( 36905 config, 36906 config.transformResponse, 36907 response 36908 ); 36909 36910 response.headers = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"].from(response.headers); 36911 36912 return response; 36913 }, function onAdapterRejection(reason) { 36914 if (!(0,_cancel_isCancel_js__WEBPACK_IMPORTED_MODULE_5__["default"])(reason)) { 36915 throwIfCancellationRequested(config); 36916 36917 // Transform response data 36918 if (reason && reason.response) { 36919 reason.response.data = _transformData_js__WEBPACK_IMPORTED_MODULE_2__["default"].call( 36920 config, 36921 config.transformResponse, 36922 reason.response 36923 ); 36924 reason.response.headers = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"].from(reason.response.headers); 36925 } 36926 } 36927 36928 return Promise.reject(reason); 36929 }); 36930} 36931 36932 36933/***/ }), 36934
vendor: 4,787 bytes, lines 36935-37057
36935/***/ "./node_modules/axios/lib/core/mergeConfig.js": 36936/*!****************************************************!*\ 36937 !*** ./node_modules/axios/lib/core/mergeConfig.js ***! 36938 \****************************************************/ 36939/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 36940 36941"use strict"; 36942__webpack_require__.r(__webpack_exports__); 36943/* harmony export */ __webpack_require__.d(__webpack_exports__, { 36944/* harmony export */ "default": () => (/* binding */ mergeConfig) 36945/* harmony export */ }); 36946/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 36947/* harmony import */ var _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js"); 36948 36949 36950 36951 36952 36953const headersToObject = (thing) => thing instanceof _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_0__["default"] ? { ...thing } : thing; 36954 36955/** 36956 * Config-specific merge-function which creates a new config-object 36957 * by merging two configuration objects together. 36958 * 36959 * @param {Object} config1 36960 * @param {Object} config2 36961 * 36962 * @returns {Object} New object resulting from merging config2 to config1 36963 */ 36964function mergeConfig(config1, config2) { 36965 // eslint-disable-next-line no-param-reassign 36966 config2 = config2 || {}; 36967 const config = {}; 36968 36969 function getMergedValue(target, source, prop, caseless) { 36970 if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isPlainObject(target) && _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isPlainObject(source)) { 36971 return _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].merge.call({caseless}, target, source); 36972 } else if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isPlainObject(source)) { 36973 return _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].merge({}, source); 36974 } else if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isArray(source)) { 36975 return source.slice(); 36976 } 36977 return source; 36978 } 36979 36980 // eslint-disable-next-line consistent-return 36981 function mergeDeepProperties(a, b, prop , caseless) { 36982 if (!_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isUndefined(b)) { 36983 return getMergedValue(a, b, prop , caseless); 36984 } else if (!_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isUndefined(a)) { 36985 return getMergedValue(undefined, a, prop , caseless); 36986 } 36987 } 36988 36989 // eslint-disable-next-line consistent-return 36990 function valueFromConfig2(a, b) { 36991 if (!_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isUndefined(b)) { 36992 return getMergedValue(undefined, b); 36993 } 36994 } 36995 36996 // eslint-disable-next-line consistent-return 36997 function defaultToConfig2(a, b) { 36998 if (!_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isUndefined(b)) { 36999 return getMergedValue(undefined, b); 37000 } else if (!_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isUndefined(a)) { 37001 return getMergedValue(undefined, a); 37002 } 37003 } 37004 37005 // eslint-disable-next-line consistent-return 37006 function mergeDirectKeys(a, b, prop) { 37007 if (prop in config2) { 37008 return getMergedValue(a, b); 37009 } else if (prop in config1) { 37010 return getMergedValue(undefined, a); 37011 } 37012 } 37013 37014 const mergeMap = { 37015 url: valueFromConfig2, 37016 method: valueFromConfig2, 37017 data: valueFromConfig2, 37018 baseURL: defaultToConfig2, 37019 transformRequest: defaultToConfig2, 37020 transformResponse: defaultToConfig2, 37021 paramsSerializer: defaultToConfig2, 37022 timeout: defaultToConfig2, 37023 timeoutMessage: defaultToConfig2, 37024 withCredentials: defaultToConfig2, 37025 withXSRFToken: defaultToConfig2, 37026 adapter: defaultToConfig2, 37027 responseType: defaultToConfig2, 37028 xsrfCookieName: defaultToConfig2, 37029 xsrfHeaderName: defaultToConfig2, 37030 onUploadProgress: defaultToConfig2, 37031 onDownloadProgress: defaultToConfig2, 37032 decompress: defaultToConfig2, 37033 maxContentLength: defaultToConfig2, 37034 maxBodyLength: defaultToConfig2, 37035 beforeRedirect: defaultToConfig2, 37036 transport: defaultToConfig2, 37037 httpAgent: defaultToConfig2, 37038 httpsAgent: defaultToConfig2, 37039 cancelToken: defaultToConfig2, 37040 socketPath: defaultToConfig2, 37041 responseEncoding: defaultToConfig2, 37042 validateStatus: mergeDirectKeys, 37043 headers: (a, b , prop) => mergeDeepProperties(headersToObject(a), headersToObject(b),prop, true) 37044 }; 37045 37046 _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) { 37047 const merge = mergeMap[prop] || mergeDeepProperties; 37048 const configValue = merge(config1[prop], config2[prop], prop); 37049 (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue); 37050 }); 37051 37052 return config; 37053} 37054 37055 37056/***/ }), 37057
vendor: 1,586 bytes, lines 37058-37100
37058/***/ "./node_modules/axios/lib/core/settle.js": 37059/*!***********************************************!*\ 37060 !*** ./node_modules/axios/lib/core/settle.js ***! 37061 \***********************************************/ 37062/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37063 37064"use strict"; 37065__webpack_require__.r(__webpack_exports__); 37066/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37067/* harmony export */ "default": () => (/* binding */ settle) 37068/* harmony export */ }); 37069/* harmony import */ var _AxiosError_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js"); 37070 37071 37072 37073 37074/** 37075 * Resolve or reject a Promise based on response status. 37076 * 37077 * @param {Function} resolve A function that resolves the promise. 37078 * @param {Function} reject A function that rejects the promise. 37079 * @param {object} response The response. 37080 * 37081 * @returns {object} The response. 37082 */ 37083function settle(resolve, reject, response) { 37084 const validateStatus = response.config.validateStatus; 37085 if (!response.status || !validateStatus || validateStatus(response.status)) { 37086 resolve(response); 37087 } else { 37088 reject(new _AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"]( 37089 'Request failed with status code ' + response.status, 37090 [_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"].ERR_BAD_REQUEST, _AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"].ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4], 37091 response.config, 37092 response.request, 37093 response 37094 )); 37095 } 37096} 37097 37098 37099/***/ }), 37100
vendor: 1,818 bytes, lines 37101-37146
37101/***/ "./node_modules/axios/lib/core/transformData.js": 37102/*!******************************************************!*\ 37103 !*** ./node_modules/axios/lib/core/transformData.js ***! 37104 \******************************************************/ 37105/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37106 37107"use strict"; 37108__webpack_require__.r(__webpack_exports__); 37109/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37110/* harmony export */ "default": () => (/* binding */ transformData) 37111/* harmony export */ }); 37112/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js"); 37113/* harmony import */ var _defaults_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../defaults/index.js */ "./node_modules/axios/lib/defaults/index.js"); 37114/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js"); 37115 37116 37117 37118 37119 37120 37121/** 37122 * Transform the data for a request or a response 37123 * 37124 * @param {Array|Function} fns A single function or Array of functions 37125 * @param {?Object} response The response object 37126 * 37127 * @returns {*} The resulting transformed data 37128 */ 37129function transformData(fns, response) { 37130 const config = this || _defaults_index_js__WEBPACK_IMPORTED_MODULE_0__["default"]; 37131 const context = response || config; 37132 const headers = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"].from(context.headers); 37133 let data = context.data; 37134 37135 _utils_js__WEBPACK_IMPORTED_MODULE_2__["default"].forEach(fns, function transform(fn) { 37136 data = fn.call(config, data, headers.normalize(), response ? response.status : undefined); 37137 }); 37138 37139 headers.normalize(); 37140 37141 return data; 37142} 37143 37144 37145/***/ }), 37146
vendor: 7,142 bytes, lines 37147-37329
37147/***/ "./node_modules/axios/lib/defaults/index.js": 37148/*!**************************************************!*\ 37149 !*** ./node_modules/axios/lib/defaults/index.js ***! 37150 \**************************************************/ 37151/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37152 37153"use strict"; 37154__webpack_require__.r(__webpack_exports__); 37155/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37156/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 37157/* harmony export */ }); 37158/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 37159/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js"); 37160/* harmony import */ var _transitional_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./transitional.js */ "./node_modules/axios/lib/defaults/transitional.js"); 37161/* harmony import */ var _helpers_toFormData_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../helpers/toFormData.js */ "./node_modules/axios/lib/helpers/toFormData.js"); 37162/* harmony import */ var _helpers_toURLEncodedForm_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../helpers/toURLEncodedForm.js */ "./node_modules/axios/lib/helpers/toURLEncodedForm.js"); 37163/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js"); 37164/* harmony import */ var _helpers_formDataToJSON_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../helpers/formDataToJSON.js */ "./node_modules/axios/lib/helpers/formDataToJSON.js"); 37165 37166 37167 37168 37169 37170 37171 37172 37173 37174 37175/** 37176 * It takes a string, tries to parse it, and if it fails, it returns the stringified version 37177 * of the input 37178 * 37179 * @param {any} rawValue - The value to be stringified. 37180 * @param {Function} parser - A function that parses a string into a JavaScript object. 37181 * @param {Function} encoder - A function that takes a value and returns a string. 37182 * 37183 * @returns {string} A stringified version of the rawValue. 37184 */ 37185function stringifySafely(rawValue, parser, encoder) { 37186 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(rawValue)) { 37187 try { 37188 (parser || JSON.parse)(rawValue); 37189 return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].trim(rawValue); 37190 } catch (e) { 37191 if (e.name !== 'SyntaxError') { 37192 throw e; 37193 } 37194 } 37195 } 37196 37197 return (encoder || JSON.stringify)(rawValue); 37198} 37199 37200const defaults = { 37201 37202 transitional: _transitional_js__WEBPACK_IMPORTED_MODULE_1__["default"], 37203 37204 adapter: ['xhr', 'http', 'fetch'], 37205 37206 transformRequest: [function transformRequest(data, headers) { 37207 const contentType = headers.getContentType() || ''; 37208 const hasJSONContentType = contentType.indexOf('application/json') > -1; 37209 const isObjectPayload = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(data); 37210 37211 if (isObjectPayload && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isHTMLForm(data)) { 37212 data = new FormData(data); 37213 } 37214 37215 const isFormData = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFormData(data); 37216 37217 if (isFormData) { 37218 return hasJSONContentType ? JSON.stringify((0,_helpers_formDataToJSON_js__WEBPACK_IMPORTED_MODULE_2__["default"])(data)) : data; 37219 } 37220 37221 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArrayBuffer(data) || 37222 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isBuffer(data) || 37223 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isStream(data) || 37224 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFile(data) || 37225 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isBlob(data) || 37226 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isReadableStream(data) 37227 ) { 37228 return data; 37229 } 37230 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArrayBufferView(data)) { 37231 return data.buffer; 37232 } 37233 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isURLSearchParams(data)) { 37234 headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false); 37235 return data.toString(); 37236 } 37237 37238 let isFileList; 37239 37240 if (isObjectPayload) { 37241 if (contentType.indexOf('application/x-www-form-urlencoded') > -1) { 37242 return (0,_helpers_toURLEncodedForm_js__WEBPACK_IMPORTED_MODULE_3__["default"])(data, this.formSerializer).toString(); 37243 } 37244 37245 if ((isFileList = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) { 37246 const _FormData = this.env && this.env.FormData; 37247 37248 return (0,_helpers_toFormData_js__WEBPACK_IMPORTED_MODULE_4__["default"])( 37249 isFileList ? {'files[]': data} : data, 37250 _FormData && new _FormData(), 37251 this.formSerializer 37252 ); 37253 } 37254 } 37255 37256 if (isObjectPayload || hasJSONContentType ) { 37257 headers.setContentType('application/json', false); 37258 return stringifySafely(data); 37259 } 37260 37261 return data; 37262 }], 37263 37264 transformResponse: [function transformResponse(data) { 37265 const transitional = this.transitional || defaults.transitional; 37266 const forcedJSONParsing = transitional && transitional.forcedJSONParsing; 37267 const JSONRequested = this.responseType === 'json'; 37268 37269 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isResponse(data) || _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isReadableStream(data)) { 37270 return data; 37271 } 37272 37273 if (data && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) { 37274 const silentJSONParsing = transitional && transitional.silentJSONParsing; 37275 const strictJSONParsing = !silentJSONParsing && JSONRequested; 37276 37277 try { 37278 return JSON.parse(data); 37279 } catch (e) { 37280 if (strictJSONParsing) { 37281 if (e.name === 'SyntaxError') { 37282 throw _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_5__["default"].from(e, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_5__["default"].ERR_BAD_RESPONSE, this, null, this.response); 37283 } 37284 throw e; 37285 } 37286 } 37287 } 37288 37289 return data; 37290 }], 37291 37292 /** 37293 * A timeout in milliseconds to abort a request. If set to 0 (default) a 37294 * timeout is not created. 37295 */ 37296 timeout: 0, 37297 37298 xsrfCookieName: 'XSRF-TOKEN', 37299 xsrfHeaderName: 'X-XSRF-TOKEN', 37300 37301 maxContentLength: -1, 37302 maxBodyLength: -1, 37303 37304 env: { 37305 FormData: _platform_index_js__WEBPACK_IMPORTED_MODULE_6__["default"].classes.FormData, 37306 Blob: _platform_index_js__WEBPACK_IMPORTED_MODULE_6__["default"].classes.Blob 37307 }, 37308 37309 validateStatus: function validateStatus(status) { 37310 return status >= 200 && status < 300; 37311 }, 37312 37313 headers: { 37314 common: { 37315 'Accept': 'application/json, text/plain, */*', 37316 'Content-Type': undefined 37317 } 37318 } 37319}; 37320 37321_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => { 37322 defaults.headers[method] = {}; 37323}); 37324 37325/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (defaults); 37326 37327 37328/***/ }), 37329
vendor: 727 bytes, lines 37330-37351
37330/***/ "./node_modules/axios/lib/defaults/transitional.js": 37331/*!*********************************************************!*\ 37332 !*** ./node_modules/axios/lib/defaults/transitional.js ***! 37333 \*********************************************************/ 37334/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37335 37336"use strict"; 37337__webpack_require__.r(__webpack_exports__); 37338/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37339/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 37340/* harmony export */ }); 37341 37342 37343/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({ 37344 silentJSONParsing: true, 37345 forcedJSONParsing: true, 37346 clarifyTimeoutError: false 37347}); 37348 37349 37350/***/ }), 37351
vendor: 536 bytes, lines 37352-37366
37352/***/ "./node_modules/axios/lib/env/data.js": 37353/*!********************************************!*\ 37354 !*** ./node_modules/axios/lib/env/data.js ***! 37355 \********************************************/ 37356/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37357 37358"use strict"; 37359__webpack_require__.r(__webpack_exports__); 37360/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37361/* harmony export */ VERSION: () => (/* binding */ VERSION) 37362/* harmony export */ }); 37363const VERSION = "1.8.4"; 37364 37365/***/ }), 37366
vendor: 2,248 bytes, lines 37367-37440
37367/***/ "./node_modules/axios/lib/helpers/AxiosURLSearchParams.js": 37368/*!****************************************************************!*\ 37369 !*** ./node_modules/axios/lib/helpers/AxiosURLSearchParams.js ***! 37370 \****************************************************************/ 37371/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37372 37373"use strict"; 37374__webpack_require__.r(__webpack_exports__); 37375/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37376/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 37377/* harmony export */ }); 37378/* harmony import */ var _toFormData_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./toFormData.js */ "./node_modules/axios/lib/helpers/toFormData.js"); 37379 37380 37381 37382 37383/** 37384 * It encodes a string by replacing all characters that are not in the unreserved set with 37385 * their percent-encoded equivalents 37386 * 37387 * @param {string} str - The string to encode. 37388 * 37389 * @returns {string} The encoded string. 37390 */ 37391function encode(str) { 37392 const charMap = { 37393 '!': '%21', 37394 "'": '%27', 37395 '(': '%28', 37396 ')': '%29', 37397 '~': '%7E', 37398 '%20': '+', 37399 '%00': '\x00' 37400 }; 37401 return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) { 37402 return charMap[match]; 37403 }); 37404} 37405 37406/** 37407 * It takes a params object and converts it to a FormData object 37408 * 37409 * @param {Object<string, any>} params - The parameters to be converted to a FormData object. 37410 * @param {Object<string, any>} options - The options object passed to the Axios constructor. 37411 * 37412 * @returns {void} 37413 */ 37414function AxiosURLSearchParams(params, options) { 37415 this._pairs = []; 37416 37417 params && (0,_toFormData_js__WEBPACK_IMPORTED_MODULE_0__["default"])(params, this, options); 37418} 37419 37420const prototype = AxiosURLSearchParams.prototype; 37421 37422prototype.append = function append(name, value) { 37423 this._pairs.push([name, value]); 37424}; 37425 37426prototype.toString = function toString(encoder) { 37427 const _encode = encoder ? function(value) { 37428 return encoder.call(this, value, encode); 37429 } : encode; 37430 37431 return this._pairs.map(function each(pair) { 37432 return _encode(pair[0]) + '=' + _encode(pair[1]); 37433 }, '').join('&'); 37434}; 37435 37436/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (AxiosURLSearchParams); 37437 37438 37439/***/ }), 37440
vendor: 2,226 bytes, lines 37441-37526
37441/***/ "./node_modules/axios/lib/helpers/HttpStatusCode.js": 37442/*!**********************************************************!*\ 37443 !*** ./node_modules/axios/lib/helpers/HttpStatusCode.js ***! 37444 \**********************************************************/ 37445/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37446 37447"use strict"; 37448__webpack_require__.r(__webpack_exports__); 37449/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37450/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 37451/* harmony export */ }); 37452const HttpStatusCode = { 37453 Continue: 100, 37454 SwitchingProtocols: 101, 37455 Processing: 102, 37456 EarlyHints: 103, 37457 Ok: 200, 37458 Created: 201, 37459 Accepted: 202, 37460 NonAuthoritativeInformation: 203, 37461 NoContent: 204, 37462 ResetContent: 205, 37463 PartialContent: 206, 37464 MultiStatus: 207, 37465 AlreadyReported: 208, 37466 ImUsed: 226, 37467 MultipleChoices: 300, 37468 MovedPermanently: 301, 37469 Found: 302, 37470 SeeOther: 303, 37471 NotModified: 304, 37472 UseProxy: 305, 37473 Unused: 306, 37474 TemporaryRedirect: 307, 37475 PermanentRedirect: 308, 37476 BadRequest: 400, 37477 Unauthorized: 401, 37478 PaymentRequired: 402, 37479 Forbidden: 403, 37480 NotFound: 404, 37481 MethodNotAllowed: 405, 37482 NotAcceptable: 406, 37483 ProxyAuthenticationRequired: 407, 37484 RequestTimeout: 408, 37485 Conflict: 409, 37486 Gone: 410, 37487 LengthRequired: 411, 37488 PreconditionFailed: 412, 37489 PayloadTooLarge: 413, 37490 UriTooLong: 414, 37491 UnsupportedMediaType: 415, 37492 RangeNotSatisfiable: 416, 37493 ExpectationFailed: 417, 37494 ImATeapot: 418, 37495 MisdirectedRequest: 421, 37496 UnprocessableEntity: 422, 37497 Locked: 423, 37498 FailedDependency: 424, 37499 TooEarly: 425, 37500 UpgradeRequired: 426, 37501 PreconditionRequired: 428, 37502 TooManyRequests: 429, 37503 RequestHeaderFieldsTooLarge: 431, 37504 UnavailableForLegalReasons: 451, 37505 InternalServerError: 500, 37506 NotImplemented: 501, 37507 BadGateway: 502, 37508 ServiceUnavailable: 503, 37509 GatewayTimeout: 504, 37510 HttpVersionNotSupported: 505, 37511 VariantAlsoNegotiates: 506, 37512 InsufficientStorage: 507, 37513 LoopDetected: 508, 37514 NotExtended: 510, 37515 NetworkAuthenticationRequired: 511, 37516}; 37517 37518Object.entries(HttpStatusCode).forEach(([key, value]) => { 37519 HttpStatusCode[value] = key; 37520}); 37521 37522/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (HttpStatusCode); 37523 37524 37525/***/ }), 37526
vendor: 633 bytes, lines 37527-37548
37527/***/ "./node_modules/axios/lib/helpers/bind.js": 37528/*!************************************************!*\ 37529 !*** ./node_modules/axios/lib/helpers/bind.js ***! 37530 \************************************************/ 37531/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37532 37533"use strict"; 37534__webpack_require__.r(__webpack_exports__); 37535/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37536/* harmony export */ "default": () => (/* binding */ bind) 37537/* harmony export */ }); 37538 37539 37540function bind(fn, thisArg) { 37541 return function wrap() { 37542 return fn.apply(thisArg, arguments); 37543 }; 37544} 37545 37546 37547/***/ }), 37548
vendor: 2,571 bytes, lines 37549-37634
37549/***/ "./node_modules/axios/lib/helpers/buildURL.js": 37550/*!****************************************************!*\ 37551 !*** ./node_modules/axios/lib/helpers/buildURL.js ***! 37552 \****************************************************/ 37553/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37554 37555"use strict"; 37556__webpack_require__.r(__webpack_exports__); 37557/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37558/* harmony export */ "default": () => (/* binding */ buildURL) 37559/* harmony export */ }); 37560/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 37561/* harmony import */ var _helpers_AxiosURLSearchParams_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../helpers/AxiosURLSearchParams.js */ "./node_modules/axios/lib/helpers/AxiosURLSearchParams.js"); 37562 37563 37564 37565 37566 37567/** 37568 * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their 37569 * URI encoded counterparts 37570 * 37571 * @param {string} val The value to be encoded. 37572 * 37573 * @returns {string} The encoded value. 37574 */ 37575function encode(val) { 37576 return encodeURIComponent(val). 37577 replace(/%3A/gi, ':'). 37578 replace(/%24/g, '$'). 37579 replace(/%2C/gi, ','). 37580 replace(/%20/g, '+'). 37581 replace(/%5B/gi, '['). 37582 replace(/%5D/gi, ']'); 37583} 37584 37585/** 37586 * Build a URL by appending params to the end 37587 * 37588 * @param {string} url The base of the url (e.g., http://www.google.com) 37589 * @param {object} [params] The params to be appended 37590 * @param {?(object|Function)} options 37591 * 37592 * @returns {string} The formatted url 37593 */ 37594function buildURL(url, params, options) { 37595 /*eslint no-param-reassign:0*/ 37596 if (!params) { 37597 return url; 37598 } 37599 37600 const _encode = options && options.encode || encode; 37601 37602 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(options)) { 37603 options = { 37604 serialize: options 37605 }; 37606 } 37607 37608 const serializeFn = options && options.serialize; 37609 37610 let serializedParams; 37611 37612 if (serializeFn) { 37613 serializedParams = serializeFn(params, options); 37614 } else { 37615 serializedParams = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isURLSearchParams(params) ? 37616 params.toString() : 37617 new _helpers_AxiosURLSearchParams_js__WEBPACK_IMPORTED_MODULE_1__["default"](params, options).toString(_encode); 37618 } 37619 37620 if (serializedParams) { 37621 const hashmarkIndex = url.indexOf("#"); 37622 37623 if (hashmarkIndex !== -1) { 37624 url = url.slice(0, hashmarkIndex); 37625 } 37626 url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams; 37627 } 37628 37629 return url; 37630} 37631 37632 37633/***/ }), 37634
vendor: 916 bytes, lines 37635-37664
37635/***/ "./node_modules/axios/lib/helpers/combineURLs.js": 37636/*!*******************************************************!*\ 37637 !*** ./node_modules/axios/lib/helpers/combineURLs.js ***! 37638 \*******************************************************/ 37639/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37640 37641"use strict"; 37642__webpack_require__.r(__webpack_exports__); 37643/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37644/* harmony export */ "default": () => (/* binding */ combineURLs) 37645/* harmony export */ }); 37646 37647 37648/** 37649 * Creates a new URL by combining the specified URLs 37650 * 37651 * @param {string} baseURL The base URL 37652 * @param {string} relativeURL The relative URL 37653 * 37654 * @returns {string} The combined URL 37655 */ 37656function combineURLs(baseURL, relativeURL) { 37657 return relativeURL 37658 ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '') 37659 : baseURL; 37660} 37661 37662 37663/***/ }), 37664
vendor: 2,602 bytes, lines 37665-37730
37665/***/ "./node_modules/axios/lib/helpers/composeSignals.js": 37666/*!**********************************************************!*\ 37667 !*** ./node_modules/axios/lib/helpers/composeSignals.js ***! 37668 \**********************************************************/ 37669/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37670 37671"use strict"; 37672__webpack_require__.r(__webpack_exports__); 37673/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37674/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 37675/* harmony export */ }); 37676/* harmony import */ var _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../cancel/CanceledError.js */ "./node_modules/axios/lib/cancel/CanceledError.js"); 37677/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js"); 37678/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 37679 37680 37681 37682 37683const composeSignals = (signals, timeout) => { 37684 const {length} = (signals = signals ? signals.filter(Boolean) : []); 37685 37686 if (timeout || length) { 37687 let controller = new AbortController(); 37688 37689 let aborted; 37690 37691 const onabort = function (reason) { 37692 if (!aborted) { 37693 aborted = true; 37694 unsubscribe(); 37695 const err = reason instanceof Error ? reason : this.reason; 37696 controller.abort(err instanceof _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"] ? err : new _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_1__["default"](err instanceof Error ? err.message : err)); 37697 } 37698 } 37699 37700 let timer = timeout && setTimeout(() => { 37701 timer = null; 37702 onabort(new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"](`timeout ${timeout} of ms exceeded`, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"].ETIMEDOUT)) 37703 }, timeout) 37704 37705 const unsubscribe = () => { 37706 if (signals) { 37707 timer && clearTimeout(timer); 37708 timer = null; 37709 signals.forEach(signal => { 37710 signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort); 37711 }); 37712 signals = null; 37713 } 37714 } 37715 37716 signals.forEach((signal) => signal.addEventListener('abort', onabort)); 37717 37718 const {signal} = controller; 37719 37720 signal.unsubscribe = () => _utils_js__WEBPACK_IMPORTED_MODULE_2__["default"].asap(unsubscribe); 37721 37722 return signal; 37723 } 37724} 37725 37726/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (composeSignals); 37727 37728 37729/***/ }), 37730
vendor: 2,062 bytes, lines 37731-37789
37731/***/ "./node_modules/axios/lib/helpers/cookies.js": 37732/*!***************************************************!*\ 37733 !*** ./node_modules/axios/lib/helpers/cookies.js ***! 37734 \***************************************************/ 37735/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37736 37737"use strict"; 37738__webpack_require__.r(__webpack_exports__); 37739/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37740/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 37741/* harmony export */ }); 37742/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js"); 37743/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js"); 37744 37745 37746 37747/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].hasStandardBrowserEnv ? 37748 37749 // Standard browser envs support document.cookie 37750 { 37751 write(name, value, expires, path, domain, secure) { 37752 const cookie = [name + '=' + encodeURIComponent(value)]; 37753 37754 _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString()); 37755 37756 _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isString(path) && cookie.push('path=' + path); 37757 37758 _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isString(domain) && cookie.push('domain=' + domain); 37759 37760 secure === true && cookie.push('secure'); 37761 37762 document.cookie = cookie.join('; '); 37763 }, 37764 37765 read(name) { 37766 const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)')); 37767 return (match ? decodeURIComponent(match[3]) : null); 37768 }, 37769 37770 remove(name) { 37771 this.write(name, '', Date.now() - 86400000); 37772 } 37773 } 37774 37775 : 37776 37777 // Non-standard browser env (web workers, react-native) lack needed support. 37778 { 37779 write() {}, 37780 read() { 37781 return null; 37782 }, 37783 remove() {} 37784 }); 37785 37786 37787 37788/***/ }), 37789
vendor: 3,240 bytes, lines 37790-37900
37790/***/ "./node_modules/axios/lib/helpers/formDataToJSON.js": 37791/*!**********************************************************!*\ 37792 !*** ./node_modules/axios/lib/helpers/formDataToJSON.js ***! 37793 \**********************************************************/ 37794/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37795 37796"use strict"; 37797__webpack_require__.r(__webpack_exports__); 37798/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37799/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 37800/* harmony export */ }); 37801/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 37802 37803 37804 37805 37806/** 37807 * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z'] 37808 * 37809 * @param {string} name - The name of the property to get. 37810 * 37811 * @returns An array of strings. 37812 */ 37813function parsePropPath(name) { 37814 // foo[x][y][z] 37815 // foo.x.y.z 37816 // foo-x-y-z 37817 // foo x y z 37818 return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].matchAll(/\w+|\[(\w*)]/g, name).map(match => { 37819 return match[0] === '[]' ? '' : match[1] || match[0]; 37820 }); 37821} 37822 37823/** 37824 * Convert an array to an object. 37825 * 37826 * @param {Array<any>} arr - The array to convert to an object. 37827 * 37828 * @returns An object with the same keys and values as the array. 37829 */ 37830function arrayToObject(arr) { 37831 const obj = {}; 37832 const keys = Object.keys(arr); 37833 let i; 37834 const len = keys.length; 37835 let key; 37836 for (i = 0; i < len; i++) { 37837 key = keys[i]; 37838 obj[key] = arr[key]; 37839 } 37840 return obj; 37841} 37842 37843/** 37844 * It takes a FormData object and returns a JavaScript object 37845 * 37846 * @param {string} formData The FormData object to convert to JSON. 37847 * 37848 * @returns {Object<string, any> | null} The converted object. 37849 */ 37850function formDataToJSON(formData) { 37851 function buildPath(path, value, target, index) { 37852 let name = path[index++]; 37853 37854 if (name === '__proto__') return true; 37855 37856 const isNumericKey = Number.isFinite(+name); 37857 const isLast = index >= path.length; 37858 name = !name && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(target) ? target.length : name; 37859 37860 if (isLast) { 37861 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].hasOwnProp(target, name)) { 37862 target[name] = [target[name], value]; 37863 } else { 37864 target[name] = value; 37865 } 37866 37867 return !isNumericKey; 37868 } 37869 37870 if (!target[name] || !_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(target[name])) { 37871 target[name] = []; 37872 } 37873 37874 const result = buildPath(path, value, target[name], index); 37875 37876 if (result && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(target[name])) { 37877 target[name] = arrayToObject(target[name]); 37878 } 37879 37880 return !isNumericKey; 37881 } 37882 37883 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFormData(formData) && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(formData.entries)) { 37884 const obj = {}; 37885 37886 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEachEntry(formData, (name, value) => { 37887 buildPath(parsePropPath(name), value, obj, 0); 37888 }); 37889 37890 return obj; 37891 } 37892 37893 return null; 37894} 37895 37896/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (formDataToJSON); 37897 37898 37899/***/ }), 37900
vendor: 1,105 bytes, lines 37901-37930
37901/***/ "./node_modules/axios/lib/helpers/isAbsoluteURL.js": 37902/*!*********************************************************!*\ 37903 !*** ./node_modules/axios/lib/helpers/isAbsoluteURL.js ***! 37904 \*********************************************************/ 37905/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37906 37907"use strict"; 37908__webpack_require__.r(__webpack_exports__); 37909/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37910/* harmony export */ "default": () => (/* binding */ isAbsoluteURL) 37911/* harmony export */ }); 37912 37913 37914/** 37915 * Determines whether the specified URL is absolute 37916 * 37917 * @param {string} url The URL to test 37918 * 37919 * @returns {boolean} True if the specified URL is absolute, otherwise false 37920 */ 37921function isAbsoluteURL(url) { 37922 // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL). 37923 // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed 37924 // by any combination of letters, digits, plus, period, or hyphen. 37925 return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url); 37926} 37927 37928 37929/***/ }), 37930
vendor: 1,067 bytes, lines 37931-37960
37931/***/ "./node_modules/axios/lib/helpers/isAxiosError.js": 37932/*!********************************************************!*\ 37933 !*** ./node_modules/axios/lib/helpers/isAxiosError.js ***! 37934 \********************************************************/ 37935/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37936 37937"use strict"; 37938__webpack_require__.r(__webpack_exports__); 37939/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37940/* harmony export */ "default": () => (/* binding */ isAxiosError) 37941/* harmony export */ }); 37942/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js"); 37943 37944 37945 37946 37947/** 37948 * Determines whether the payload is an error thrown by Axios 37949 * 37950 * @param {*} payload The value to test 37951 * 37952 * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false 37953 */ 37954function isAxiosError(payload) { 37955 return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(payload) && (payload.isAxiosError === true); 37956} 37957 37958 37959/***/ }), 37960
vendor: 1,426 bytes, lines 37961-37990
37961/***/ "./node_modules/axios/lib/helpers/isURLSameOrigin.js": 37962/*!***********************************************************!*\ 37963 !*** ./node_modules/axios/lib/helpers/isURLSameOrigin.js ***! 37964 \***********************************************************/ 37965/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37966 37967"use strict"; 37968__webpack_require__.r(__webpack_exports__); 37969/* harmony export */ __webpack_require__.d(__webpack_exports__, { 37970/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 37971/* harmony export */ }); 37972/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js"); 37973 37974 37975/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].hasStandardBrowserEnv ? ((origin, isMSIE) => (url) => { 37976 url = new URL(url, _platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].origin); 37977 37978 return ( 37979 origin.protocol === url.protocol && 37980 origin.host === url.host && 37981 (isMSIE || origin.port === url.port) 37982 ); 37983})( 37984 new URL(_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].origin), 37985 _platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].navigator && /(msie|trident)/i.test(_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].navigator.userAgent) 37986) : () => true); 37987 37988 37989/***/ }), 37990
vendor: 642 bytes, lines 37991-38007
37991/***/ "./node_modules/axios/lib/helpers/null.js": 37992/*!************************************************!*\ 37993 !*** ./node_modules/axios/lib/helpers/null.js ***! 37994 \************************************************/ 37995/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 37996 37997"use strict"; 37998__webpack_require__.r(__webpack_exports__); 37999/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38000/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38001/* harmony export */ }); 38002// eslint-disable-next-line strict 38003/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (null); 38004 38005 38006/***/ }), 38007
vendor: 2,142 bytes, lines 38008-38078
38008/***/ "./node_modules/axios/lib/helpers/parseHeaders.js": 38009/*!********************************************************!*\ 38010 !*** ./node_modules/axios/lib/helpers/parseHeaders.js ***! 38011 \********************************************************/ 38012/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38013 38014"use strict"; 38015__webpack_require__.r(__webpack_exports__); 38016/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38017/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38018/* harmony export */ }); 38019/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js"); 38020 38021 38022 38023 38024// RawAxiosHeaders whose duplicates are ignored by node 38025// c.f. https://nodejs.org/api/http.html#http_message_headers 38026const ignoreDuplicateOf = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toObjectSet([ 38027 'age', 'authorization', 'content-length', 'content-type', 'etag', 38028 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since', 38029 'last-modified', 'location', 'max-forwards', 'proxy-authorization', 38030 'referer', 'retry-after', 'user-agent' 38031]); 38032 38033/** 38034 * Parse headers into an object 38035 * 38036 * ``` 38037 * Date: Wed, 27 Aug 2014 08:58:49 GMT 38038 * Content-Type: application/json 38039 * Connection: keep-alive 38040 * Transfer-Encoding: chunked 38041 * ``` 38042 * 38043 * @param {String} rawHeaders Headers needing to be parsed 38044 * 38045 * @returns {Object} Headers parsed into an object 38046 */ 38047/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (rawHeaders => { 38048 const parsed = {}; 38049 let key; 38050 let val; 38051 let i; 38052 38053 rawHeaders && rawHeaders.split('\n').forEach(function parser(line) { 38054 i = line.indexOf(':'); 38055 key = line.substring(0, i).trim().toLowerCase(); 38056 val = line.substring(i + 1).trim(); 38057 38058 if (!key || (parsed[key] && ignoreDuplicateOf[key])) { 38059 return; 38060 } 38061 38062 if (key === 'set-cookie') { 38063 if (parsed[key]) { 38064 parsed[key].push(val); 38065 } else { 38066 parsed[key] = [val]; 38067 } 38068 } else { 38069 parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val; 38070 } 38071 }); 38072 38073 return parsed; 38074}); 38075 38076 38077/***/ }), 38078
vendor: 695 bytes, lines 38079-38099
38079/***/ "./node_modules/axios/lib/helpers/parseProtocol.js": 38080/*!*********************************************************!*\ 38081 !*** ./node_modules/axios/lib/helpers/parseProtocol.js ***! 38082 \*********************************************************/ 38083/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38084 38085"use strict"; 38086__webpack_require__.r(__webpack_exports__); 38087/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38088/* harmony export */ "default": () => (/* binding */ parseProtocol) 38089/* harmony export */ }); 38090 38091 38092function parseProtocol(url) { 38093 const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url); 38094 return match && match[1] || ''; 38095} 38096 38097 38098/***/ }), 38099
vendor: 2,500 bytes, lines 38100-38163
38100/***/ "./node_modules/axios/lib/helpers/progressEventReducer.js": 38101/*!****************************************************************!*\ 38102 !*** ./node_modules/axios/lib/helpers/progressEventReducer.js ***! 38103 \****************************************************************/ 38104/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38105 38106"use strict"; 38107__webpack_require__.r(__webpack_exports__); 38108/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38109/* harmony export */ asyncDecorator: () => (/* binding */ asyncDecorator), 38110/* harmony export */ progressEventDecorator: () => (/* binding */ progressEventDecorator), 38111/* harmony export */ progressEventReducer: () => (/* binding */ progressEventReducer) 38112/* harmony export */ }); 38113/* harmony import */ var _speedometer_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./speedometer.js */ "./node_modules/axios/lib/helpers/speedometer.js"); 38114/* harmony import */ var _throttle_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./throttle.js */ "./node_modules/axios/lib/helpers/throttle.js"); 38115/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 38116 38117 38118 38119 38120const progressEventReducer = (listener, isDownloadStream, freq = 3) => { 38121 let bytesNotified = 0; 38122 const _speedometer = (0,_speedometer_js__WEBPACK_IMPORTED_MODULE_0__["default"])(50, 250); 38123 38124 return (0,_throttle_js__WEBPACK_IMPORTED_MODULE_1__["default"])(e => { 38125 const loaded = e.loaded; 38126 const total = e.lengthComputable ? e.total : undefined; 38127 const progressBytes = loaded - bytesNotified; 38128 const rate = _speedometer(progressBytes); 38129 const inRange = loaded <= total; 38130 38131 bytesNotified = loaded; 38132 38133 const data = { 38134 loaded, 38135 total, 38136 progress: total ? (loaded / total) : undefined, 38137 bytes: progressBytes, 38138 rate: rate ? rate : undefined, 38139 estimated: rate && total && inRange ? (total - loaded) / rate : undefined, 38140 event: e, 38141 lengthComputable: total != null, 38142 [isDownloadStream ? 'download' : 'upload']: true 38143 }; 38144 38145 listener(data); 38146 }, freq); 38147} 38148 38149const progressEventDecorator = (total, throttled) => { 38150 const lengthComputable = total != null; 38151 38152 return [(loaded) => throttled[0]({ 38153 lengthComputable, 38154 total, 38155 loaded 38156 }), throttled[1]]; 38157} 38158 38159const asyncDecorator = (fn) => (...args) => _utils_js__WEBPACK_IMPORTED_MODULE_2__["default"].asap(() => fn(...args)); 38160 38161 38162/***/ }), 38163
vendor: 4,274 bytes, lines 38164-38243
38164/***/ "./node_modules/axios/lib/helpers/resolveConfig.js": 38165/*!*********************************************************!*\ 38166 !*** ./node_modules/axios/lib/helpers/resolveConfig.js ***! 38167 \*********************************************************/ 38168/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38169 38170"use strict"; 38171__webpack_require__.r(__webpack_exports__); 38172/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38173/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38174/* harmony export */ }); 38175/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js"); 38176/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 38177/* harmony import */ var _isURLSameOrigin_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./isURLSameOrigin.js */ "./node_modules/axios/lib/helpers/isURLSameOrigin.js"); 38178/* harmony import */ var _cookies_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./cookies.js */ "./node_modules/axios/lib/helpers/cookies.js"); 38179/* harmony import */ var _core_buildFullPath_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../core/buildFullPath.js */ "./node_modules/axios/lib/core/buildFullPath.js"); 38180/* harmony import */ var _core_mergeConfig_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/mergeConfig.js */ "./node_modules/axios/lib/core/mergeConfig.js"); 38181/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js"); 38182/* harmony import */ var _buildURL_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./buildURL.js */ "./node_modules/axios/lib/helpers/buildURL.js"); 38183 38184 38185 38186 38187 38188 38189 38190 38191 38192/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((config) => { 38193 const newConfig = (0,_core_mergeConfig_js__WEBPACK_IMPORTED_MODULE_0__["default"])({}, config); 38194 38195 let {data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth} = newConfig; 38196 38197 newConfig.headers = headers = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"].from(headers); 38198 38199 newConfig.url = (0,_buildURL_js__WEBPACK_IMPORTED_MODULE_2__["default"])((0,_core_buildFullPath_js__WEBPACK_IMPORTED_MODULE_3__["default"])(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer); 38200 38201 // HTTP basic authentication 38202 if (auth) { 38203 headers.set('Authorization', 'Basic ' + 38204 btoa((auth.username || '') + ':' + (auth.password ? unescape(encodeURIComponent(auth.password)) : '')) 38205 ); 38206 } 38207 38208 let contentType; 38209 38210 if (_utils_js__WEBPACK_IMPORTED_MODULE_4__["default"].isFormData(data)) { 38211 if (_platform_index_js__WEBPACK_IMPORTED_MODULE_5__["default"].hasStandardBrowserEnv || _platform_index_js__WEBPACK_IMPORTED_MODULE_5__["default"].hasStandardBrowserWebWorkerEnv) { 38212 headers.setContentType(undefined); // Let the browser set it 38213 } else if ((contentType = headers.getContentType()) !== false) { 38214 // fix semicolon duplication issue for ReactNative FormData implementation 38215 const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : []; 38216 headers.setContentType([type || 'multipart/form-data', ...tokens].join('; ')); 38217 } 38218 } 38219 38220 // Add xsrf header 38221 // This is only done if running in a standard browser environment. 38222 // Specifically not if we're in a web worker, or react-native. 38223 38224 if (_platform_index_js__WEBPACK_IMPORTED_MODULE_5__["default"].hasStandardBrowserEnv) { 38225 withXSRFToken && _utils_js__WEBPACK_IMPORTED_MODULE_4__["default"].isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig)); 38226 38227 if (withXSRFToken || (withXSRFToken !== false && (0,_isURLSameOrigin_js__WEBPACK_IMPORTED_MODULE_6__["default"])(newConfig.url))) { 38228 // Add xsrf header 38229 const xsrfValue = xsrfHeaderName && xsrfCookieName && _cookies_js__WEBPACK_IMPORTED_MODULE_7__["default"].read(xsrfCookieName); 38230 38231 if (xsrfValue) { 38232 headers.set(xsrfHeaderName, xsrfValue); 38233 } 38234 } 38235 } 38236 38237 return newConfig; 38238}); 38239 38240 38241 38242/***/ }), 38243
vendor: 1,693 bytes, lines 38244-38313
38244/***/ "./node_modules/axios/lib/helpers/speedometer.js": 38245/*!*******************************************************!*\ 38246 !*** ./node_modules/axios/lib/helpers/speedometer.js ***! 38247 \*******************************************************/ 38248/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38249 38250"use strict"; 38251__webpack_require__.r(__webpack_exports__); 38252/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38253/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38254/* harmony export */ }); 38255 38256 38257/** 38258 * Calculate data maxRate 38259 * @param {Number} [samplesCount= 10] 38260 * @param {Number} [min= 1000] 38261 * @returns {Function} 38262 */ 38263function speedometer(samplesCount, min) { 38264 samplesCount = samplesCount || 10; 38265 const bytes = new Array(samplesCount); 38266 const timestamps = new Array(samplesCount); 38267 let head = 0; 38268 let tail = 0; 38269 let firstSampleTS; 38270 38271 min = min !== undefined ? min : 1000; 38272 38273 return function push(chunkLength) { 38274 const now = Date.now(); 38275 38276 const startedAt = timestamps[tail]; 38277 38278 if (!firstSampleTS) { 38279 firstSampleTS = now; 38280 } 38281 38282 bytes[head] = chunkLength; 38283 timestamps[head] = now; 38284 38285 let i = tail; 38286 let bytesCount = 0; 38287 38288 while (i !== head) { 38289 bytesCount += bytes[i++]; 38290 i = i % samplesCount; 38291 } 38292 38293 head = (head + 1) % samplesCount; 38294 38295 if (head === tail) { 38296 tail = (tail + 1) % samplesCount; 38297 } 38298 38299 if (now - firstSampleTS < min) { 38300 return; 38301 } 38302 38303 const passed = startedAt && now - startedAt; 38304 38305 return passed ? Math.round(bytesCount * 1000 / passed) : undefined; 38306 }; 38307} 38308 38309/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (speedometer); 38310 38311 38312/***/ }), 38313
vendor: 1,073 bytes, lines 38314-38356
38314/***/ "./node_modules/axios/lib/helpers/spread.js": 38315/*!**************************************************!*\ 38316 !*** ./node_modules/axios/lib/helpers/spread.js ***! 38317 \**************************************************/ 38318/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38319 38320"use strict"; 38321__webpack_require__.r(__webpack_exports__); 38322/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38323/* harmony export */ "default": () => (/* binding */ spread) 38324/* harmony export */ }); 38325 38326 38327/** 38328 * Syntactic sugar for invoking a function and expanding an array for arguments. 38329 * 38330 * Common use case would be to use `Function.prototype.apply`. 38331 * 38332 * ```js 38333 * function f(x, y, z) {} 38334 * var args = [1, 2, 3]; 38335 * f.apply(null, args); 38336 * ``` 38337 * 38338 * With `spread` this example can be re-written. 38339 * 38340 * ```js 38341 * spread(function(x, y, z) {})([1, 2, 3]); 38342 * ``` 38343 * 38344 * @param {Function} callback 38345 * 38346 * @returns {Function} 38347 */ 38348function spread(callback) { 38349 return function wrap(arr) { 38350 return callback.apply(null, arr); 38351 }; 38352} 38353 38354 38355/***/ }), 38356
vendor: 1,463 bytes, lines 38357-38415
38357/***/ "./node_modules/axios/lib/helpers/throttle.js": 38358/*!****************************************************!*\ 38359 !*** ./node_modules/axios/lib/helpers/throttle.js ***! 38360 \****************************************************/ 38361/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38362 38363"use strict"; 38364__webpack_require__.r(__webpack_exports__); 38365/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38366/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38367/* harmony export */ }); 38368/** 38369 * Throttle decorator 38370 * @param {Function} fn 38371 * @param {Number} freq 38372 * @return {Function} 38373 */ 38374function throttle(fn, freq) { 38375 let timestamp = 0; 38376 let threshold = 1000 / freq; 38377 let lastArgs; 38378 let timer; 38379 38380 const invoke = (args, now = Date.now()) => { 38381 timestamp = now; 38382 lastArgs = null; 38383 if (timer) { 38384 clearTimeout(timer); 38385 timer = null; 38386 } 38387 fn.apply(null, args); 38388 } 38389 38390 const throttled = (...args) => { 38391 const now = Date.now(); 38392 const passed = now - timestamp; 38393 if ( passed >= threshold) { 38394 invoke(args, now); 38395 } else { 38396 lastArgs = args; 38397 if (!timer) { 38398 timer = setTimeout(() => { 38399 timer = null; 38400 invoke(lastArgs) 38401 }, threshold - passed); 38402 } 38403 } 38404 } 38405 38406 const flush = () => lastArgs && invoke(lastArgs); 38407 38408 return [throttled, flush]; 38409} 38410 38411/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (throttle); 38412 38413 38414/***/ }), 38415
vendor: 8,379 bytes, lines 38416-38653
38416/***/ "./node_modules/axios/lib/helpers/toFormData.js": 38417/*!******************************************************!*\ 38418 !*** ./node_modules/axios/lib/helpers/toFormData.js ***! 38419 \******************************************************/ 38420/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38421 38422"use strict"; 38423__webpack_require__.r(__webpack_exports__); 38424/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38425/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38426/* harmony export */ }); 38427/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 38428/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js"); 38429/* harmony import */ var _platform_node_classes_FormData_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../platform/node/classes/FormData.js */ "./node_modules/axios/lib/helpers/null.js"); 38430/* provided dependency */ var Buffer = __webpack_require__(/*! buffer */ "./node_modules/buffer/index.js")["Buffer"]; 38431 38432 38433 38434 38435// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored 38436 38437 38438/** 38439 * Determines if the given thing is a array or js object. 38440 * 38441 * @param {string} thing - The object or array to be visited. 38442 * 38443 * @returns {boolean} 38444 */ 38445function isVisitable(thing) { 38446 return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isPlainObject(thing) || _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(thing); 38447} 38448 38449/** 38450 * It removes the brackets from the end of a string 38451 * 38452 * @param {string} key - The key of the parameter. 38453 * 38454 * @returns {string} the key without the brackets. 38455 */ 38456function removeBrackets(key) { 38457 return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].endsWith(key, '[]') ? key.slice(0, -2) : key; 38458} 38459 38460/** 38461 * It takes a path, a key, and a boolean, and returns a string 38462 * 38463 * @param {string} path - The path to the current key. 38464 * @param {string} key - The key of the current object being iterated over. 38465 * @param {string} dots - If true, the key will be rendered with dots instead of brackets. 38466 * 38467 * @returns {string} The path to the current key. 38468 */ 38469function renderKey(path, key, dots) { 38470 if (!path) return key; 38471 return path.concat(key).map(function each(token, i) { 38472 // eslint-disable-next-line no-param-reassign 38473 token = removeBrackets(token); 38474 return !dots && i ? '[' + token + ']' : token; 38475 }).join(dots ? '.' : ''); 38476} 38477 38478/** 38479 * If the array is an array and none of its elements are visitable, then it's a flat array. 38480 * 38481 * @param {Array<any>} arr - The array to check 38482 * 38483 * @returns {boolean} 38484 */ 38485function isFlatArray(arr) { 38486 return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(arr) && !arr.some(isVisitable); 38487} 38488 38489const predicates = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toFlatObject(_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"], {}, null, function filter(prop) { 38490 return /^is[A-Z]/.test(prop); 38491}); 38492 38493/** 38494 * Convert a data object to FormData 38495 * 38496 * @param {Object} obj 38497 * @param {?Object} [formData] 38498 * @param {?Object} [options] 38499 * @param {Function} [options.visitor] 38500 * @param {Boolean} [options.metaTokens = true] 38501 * @param {Boolean} [options.dots = false] 38502 * @param {?Boolean} [options.indexes = false] 38503 * 38504 * @returns {Object} 38505 **/ 38506 38507/** 38508 * It converts an object into a FormData object 38509 * 38510 * @param {Object<any, any>} obj - The object to convert to form data. 38511 * @param {string} formData - The FormData object to append to. 38512 * @param {Object<string, any>} options 38513 * 38514 * @returns 38515 */ 38516function toFormData(obj, formData, options) { 38517 if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(obj)) { 38518 throw new TypeError('target must be an object'); 38519 } 38520 38521 // eslint-disable-next-line no-param-reassign 38522 formData = formData || new (_platform_node_classes_FormData_js__WEBPACK_IMPORTED_MODULE_1__["default"] || FormData)(); 38523 38524 // eslint-disable-next-line no-param-reassign 38525 options = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toFlatObject(options, { 38526 metaTokens: true, 38527 dots: false, 38528 indexes: false 38529 }, false, function defined(option, source) { 38530 // eslint-disable-next-line no-eq-null,eqeqeq 38531 return !_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(source[option]); 38532 }); 38533 38534 const metaTokens = options.metaTokens; 38535 // eslint-disable-next-line no-use-before-define 38536 const visitor = options.visitor || defaultVisitor; 38537 const dots = options.dots; 38538 const indexes = options.indexes; 38539 const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob; 38540 const useBlob = _Blob && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isSpecCompliantForm(formData); 38541 38542 if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(visitor)) { 38543 throw new TypeError('visitor must be a function'); 38544 } 38545 38546 function convertValue(value) { 38547 if (value === null) return ''; 38548 38549 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isDate(value)) { 38550 return value.toISOString(); 38551 } 38552 38553 if (!useBlob && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isBlob(value)) { 38554 throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"]('Blob is not supported. Use a Buffer instead.'); 38555 } 38556 38557 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArrayBuffer(value) || _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isTypedArray(value)) { 38558 return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value); 38559 } 38560 38561 return value; 38562 } 38563 38564 /** 38565 * Default visitor. 38566 * 38567 * @param {*} value 38568 * @param {String|Number} key 38569 * @param {Array<String|Number>} path 38570 * @this {FormData} 38571 * 38572 * @returns {boolean} return true to visit the each prop of the value recursively 38573 */ 38574 function defaultVisitor(value, key, path) { 38575 let arr = value; 38576 38577 if (value && !path && typeof value === 'object') { 38578 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].endsWith(key, '{}')) { 38579 // eslint-disable-next-line no-param-reassign 38580 key = metaTokens ? key : key.slice(0, -2); 38581 // eslint-disable-next-line no-param-reassign 38582 value = JSON.stringify(value); 38583 } else if ( 38584 (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(value) && isFlatArray(value)) || 38585 ((_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFileList(value) || _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].endsWith(key, '[]')) && (arr = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toArray(value)) 38586 )) { 38587 // eslint-disable-next-line no-param-reassign 38588 key = removeBrackets(key); 38589 38590 arr.forEach(function each(el, index) { 38591 !(_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(el) || el === null) && formData.append( 38592 // eslint-disable-next-line no-nested-ternary 38593 indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'), 38594 convertValue(el) 38595 ); 38596 }); 38597 return false; 38598 } 38599 } 38600 38601 if (isVisitable(value)) { 38602 return true; 38603 } 38604 38605 formData.append(renderKey(path, key, dots), convertValue(value)); 38606 38607 return false; 38608 } 38609 38610 const stack = []; 38611 38612 const exposedHelpers = Object.assign(predicates, { 38613 defaultVisitor, 38614 convertValue, 38615 isVisitable 38616 }); 38617 38618 function build(value, path) { 38619 if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(value)) return; 38620 38621 if (stack.indexOf(value) !== -1) { 38622 throw Error('Circular reference detected in ' + path.join('.')); 38623 } 38624 38625 stack.push(value); 38626 38627 _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(value, function each(el, key) { 38628 const result = !(_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(el) || el === null) && visitor.call( 38629 formData, el, _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(key) ? key.trim() : key, path, exposedHelpers 38630 ); 38631 38632 if (result === true) { 38633 build(el, path ? path.concat(key) : [key]); 38634 } 38635 }); 38636 38637 stack.pop(); 38638 } 38639 38640 if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(obj)) { 38641 throw new TypeError('data must be an object'); 38642 } 38643 38644 build(obj); 38645 38646 return formData; 38647} 38648 38649/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (toFormData); 38650 38651 38652/***/ }), 38653
vendor: 1,660 bytes, lines 38654-38689
38654/***/ "./node_modules/axios/lib/helpers/toURLEncodedForm.js": 38655/*!************************************************************!*\ 38656 !*** ./node_modules/axios/lib/helpers/toURLEncodedForm.js ***! 38657 \************************************************************/ 38658/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38659 38660"use strict"; 38661__webpack_require__.r(__webpack_exports__); 38662/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38663/* harmony export */ "default": () => (/* binding */ toURLEncodedForm) 38664/* harmony export */ }); 38665/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js"); 38666/* harmony import */ var _toFormData_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./toFormData.js */ "./node_modules/axios/lib/helpers/toFormData.js"); 38667/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js"); 38668 38669 38670 38671 38672 38673 38674function toURLEncodedForm(data, options) { 38675 return (0,_toFormData_js__WEBPACK_IMPORTED_MODULE_0__["default"])(data, new _platform_index_js__WEBPACK_IMPORTED_MODULE_1__["default"].classes.URLSearchParams(), Object.assign({ 38676 visitor: function(value, key, path, helpers) { 38677 if (_platform_index_js__WEBPACK_IMPORTED_MODULE_1__["default"].isNode && _utils_js__WEBPACK_IMPORTED_MODULE_2__["default"].isBuffer(value)) { 38678 this.append(key, value.toString('base64')); 38679 return false; 38680 } 38681 38682 return helpers.defaultVisitor.apply(this, arguments); 38683 } 38684 }, options)); 38685} 38686 38687 38688/***/ }), 38689
vendor: 2,367 bytes, lines 38690-38793
38690/***/ "./node_modules/axios/lib/helpers/trackStream.js": 38691/*!*******************************************************!*\ 38692 !*** ./node_modules/axios/lib/helpers/trackStream.js ***! 38693 \*******************************************************/ 38694/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38695 38696"use strict"; 38697__webpack_require__.r(__webpack_exports__); 38698/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38699/* harmony export */ readBytes: () => (/* binding */ readBytes), 38700/* harmony export */ streamChunk: () => (/* binding */ streamChunk), 38701/* harmony export */ trackStream: () => (/* binding */ trackStream) 38702/* harmony export */ }); 38703 38704const streamChunk = function* (chunk, chunkSize) { 38705 let len = chunk.byteLength; 38706 38707 if (!chunkSize || len < chunkSize) { 38708 yield chunk; 38709 return; 38710 } 38711 38712 let pos = 0; 38713 let end; 38714 38715 while (pos < len) { 38716 end = pos + chunkSize; 38717 yield chunk.slice(pos, end); 38718 pos = end; 38719 } 38720} 38721 38722const readBytes = async function* (iterable, chunkSize) { 38723 for await (const chunk of readStream(iterable)) { 38724 yield* streamChunk(chunk, chunkSize); 38725 } 38726} 38727 38728const readStream = async function* (stream) { 38729 if (stream[Symbol.asyncIterator]) { 38730 yield* stream; 38731 return; 38732 } 38733 38734 const reader = stream.getReader(); 38735 try { 38736 for (;;) { 38737 const {done, value} = await reader.read(); 38738 if (done) { 38739 break; 38740 } 38741 yield value; 38742 } 38743 } finally { 38744 await reader.cancel(); 38745 } 38746} 38747 38748const trackStream = (stream, chunkSize, onProgress, onFinish) => { 38749 const iterator = readBytes(stream, chunkSize); 38750 38751 let bytes = 0; 38752 let done; 38753 let _onFinish = (e) => { 38754 if (!done) { 38755 done = true; 38756 onFinish && onFinish(e); 38757 } 38758 } 38759 38760 return new ReadableStream({ 38761 async pull(controller) { 38762 try { 38763 const {done, value} = await iterator.next(); 38764 38765 if (done) { 38766 _onFinish(); 38767 controller.close(); 38768 return; 38769 } 38770 38771 let len = value.byteLength; 38772 if (onProgress) { 38773 let loadedBytes = bytes += len; 38774 onProgress(loadedBytes); 38775 } 38776 controller.enqueue(new Uint8Array(value)); 38777 } catch (err) { 38778 _onFinish(err); 38779 throw err; 38780 } 38781 }, 38782 cancel(reason) { 38783 _onFinish(reason); 38784 return iterator.return(); 38785 } 38786 }, { 38787 highWaterMark: 2 38788 }) 38789} 38790 38791 38792/***/ }), 38793
vendor: 4,051 bytes, lines 38794-38909
38794/***/ "./node_modules/axios/lib/helpers/validator.js": 38795/*!*****************************************************!*\ 38796 !*** ./node_modules/axios/lib/helpers/validator.js ***! 38797 \*****************************************************/ 38798/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38799 38800"use strict"; 38801__webpack_require__.r(__webpack_exports__); 38802/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38803/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38804/* harmony export */ }); 38805/* harmony import */ var _env_data_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../env/data.js */ "./node_modules/axios/lib/env/data.js"); 38806/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js"); 38807 38808 38809 38810 38811 38812const validators = {}; 38813 38814// eslint-disable-next-line func-names 38815['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => { 38816 validators[type] = function validator(thing) { 38817 return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type; 38818 }; 38819}); 38820 38821const deprecatedWarnings = {}; 38822 38823/** 38824 * Transitional option validator 38825 * 38826 * @param {function|boolean?} validator - set to false if the transitional option has been removed 38827 * @param {string?} version - deprecated version / removed since version 38828 * @param {string?} message - some message with additional info 38829 * 38830 * @returns {function} 38831 */ 38832validators.transitional = function transitional(validator, version, message) { 38833 function formatMessage(opt, desc) { 38834 return '[Axios v' + _env_data_js__WEBPACK_IMPORTED_MODULE_0__.VERSION + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : ''); 38835 } 38836 38837 // eslint-disable-next-line func-names 38838 return (value, opt, opts) => { 38839 if (validator === false) { 38840 throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"]( 38841 formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')), 38842 _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].ERR_DEPRECATED 38843 ); 38844 } 38845 38846 if (version && !deprecatedWarnings[opt]) { 38847 deprecatedWarnings[opt] = true; 38848 // eslint-disable-next-line no-console 38849 console.warn( 38850 formatMessage( 38851 opt, 38852 ' has been deprecated since v' + version + ' and will be removed in the near future' 38853 ) 38854 ); 38855 } 38856 38857 return validator ? validator(value, opt, opts) : true; 38858 }; 38859}; 38860 38861validators.spelling = function spelling(correctSpelling) { 38862 return (value, opt) => { 38863 // eslint-disable-next-line no-console 38864 console.warn(`${opt} is likely a misspelling of ${correctSpelling}`); 38865 return true; 38866 } 38867}; 38868 38869/** 38870 * Assert object's properties type 38871 * 38872 * @param {object} options 38873 * @param {object} schema 38874 * @param {boolean?} allowUnknown 38875 * 38876 * @returns {object} 38877 */ 38878 38879function assertOptions(options, schema, allowUnknown) { 38880 if (typeof options !== 'object') { 38881 throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"]('options must be an object', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].ERR_BAD_OPTION_VALUE); 38882 } 38883 const keys = Object.keys(options); 38884 let i = keys.length; 38885 while (i-- > 0) { 38886 const opt = keys[i]; 38887 const validator = schema[opt]; 38888 if (validator) { 38889 const value = options[opt]; 38890 const result = value === undefined || validator(value, opt, options); 38891 if (result !== true) { 38892 throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"]('option ' + opt + ' must be ' + result, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].ERR_BAD_OPTION_VALUE); 38893 } 38894 continue; 38895 } 38896 if (allowUnknown !== true) { 38897 throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"]('Unknown option ' + opt, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].ERR_BAD_OPTION); 38898 } 38899 } 38900} 38901 38902/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({ 38903 assertOptions, 38904 validators 38905}); 38906 38907 38908/***/ }), 38909
vendor: 714 bytes, lines 38910-38927
38910/***/ "./node_modules/axios/lib/platform/browser/classes/Blob.js": 38911/*!*****************************************************************!*\ 38912 !*** ./node_modules/axios/lib/platform/browser/classes/Blob.js ***! 38913 \*****************************************************************/ 38914/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38915 38916"use strict"; 38917__webpack_require__.r(__webpack_exports__); 38918/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38919/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38920/* harmony export */ }); 38921 38922 38923/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (typeof Blob !== 'undefined' ? Blob : null); 38924 38925 38926/***/ }), 38927
vendor: 738 bytes, lines 38928-38945
38928/***/ "./node_modules/axios/lib/platform/browser/classes/FormData.js": 38929/*!*********************************************************************!*\ 38930 !*** ./node_modules/axios/lib/platform/browser/classes/FormData.js ***! 38931 \*********************************************************************/ 38932/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38933 38934"use strict"; 38935__webpack_require__.r(__webpack_exports__); 38936/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38937/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38938/* harmony export */ }); 38939 38940 38941/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (typeof FormData !== 'undefined' ? FormData : null); 38942 38943 38944/***/ }), 38945
vendor: 1,067 bytes, lines 38946-38965
38946/***/ "./node_modules/axios/lib/platform/browser/classes/URLSearchParams.js": 38947/*!****************************************************************************!*\ 38948 !*** ./node_modules/axios/lib/platform/browser/classes/URLSearchParams.js ***! 38949 \****************************************************************************/ 38950/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38951 38952"use strict"; 38953__webpack_require__.r(__webpack_exports__); 38954/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38955/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38956/* harmony export */ }); 38957/* harmony import */ var _helpers_AxiosURLSearchParams_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../helpers/AxiosURLSearchParams.js */ "./node_modules/axios/lib/helpers/AxiosURLSearchParams.js"); 38958 38959 38960 38961/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (typeof URLSearchParams !== 'undefined' ? URLSearchParams : _helpers_AxiosURLSearchParams_js__WEBPACK_IMPORTED_MODULE_0__["default"]); 38962 38963 38964/***/ }), 38965
vendor: 1,567 bytes, lines 38966-38996
38966/***/ "./node_modules/axios/lib/platform/browser/index.js": 38967/*!**********************************************************!*\ 38968 !*** ./node_modules/axios/lib/platform/browser/index.js ***! 38969 \**********************************************************/ 38970/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 38971 38972"use strict"; 38973__webpack_require__.r(__webpack_exports__); 38974/* harmony export */ __webpack_require__.d(__webpack_exports__, { 38975/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 38976/* harmony export */ }); 38977/* harmony import */ var _classes_URLSearchParams_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./classes/URLSearchParams.js */ "./node_modules/axios/lib/platform/browser/classes/URLSearchParams.js"); 38978/* harmony import */ var _classes_FormData_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./classes/FormData.js */ "./node_modules/axios/lib/platform/browser/classes/FormData.js"); 38979/* harmony import */ var _classes_Blob_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./classes/Blob.js */ "./node_modules/axios/lib/platform/browser/classes/Blob.js"); 38980 38981 38982 38983 38984/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({ 38985 isBrowser: true, 38986 classes: { 38987 URLSearchParams: _classes_URLSearchParams_js__WEBPACK_IMPORTED_MODULE_0__["default"], 38988 FormData: _classes_FormData_js__WEBPACK_IMPORTED_MODULE_1__["default"], 38989 Blob: _classes_Blob_js__WEBPACK_IMPORTED_MODULE_2__["default"] 38990 }, 38991 protocols: ['http', 'https', 'file', 'blob', 'url', 'data'] 38992}); 38993 38994 38995/***/ }), 38996
vendor: 2,378 bytes, lines 38997-39060
38997/***/ "./node_modules/axios/lib/platform/common/utils.js": 38998/*!*********************************************************!*\ 38999 !*** ./node_modules/axios/lib/platform/common/utils.js ***! 39000 \*********************************************************/ 39001/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 39002 39003"use strict"; 39004__webpack_require__.r(__webpack_exports__); 39005/* harmony export */ __webpack_require__.d(__webpack_exports__, { 39006/* harmony export */ hasBrowserEnv: () => (/* binding */ hasBrowserEnv), 39007/* harmony export */ hasStandardBrowserEnv: () => (/* binding */ hasStandardBrowserEnv), 39008/* harmony export */ hasStandardBrowserWebWorkerEnv: () => (/* binding */ hasStandardBrowserWebWorkerEnv), 39009/* harmony export */ navigator: () => (/* binding */ _navigator), 39010/* harmony export */ origin: () => (/* binding */ origin) 39011/* harmony export */ }); 39012const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined'; 39013 39014const _navigator = typeof navigator === 'object' && navigator || undefined; 39015 39016/** 39017 * Determine if we're running in a standard browser environment 39018 * 39019 * This allows axios to run in a web worker, and react-native. 39020 * Both environments support XMLHttpRequest, but not fully standard globals. 39021 * 39022 * web workers: 39023 * typeof window -> undefined 39024 * typeof document -> undefined 39025 * 39026 * react-native: 39027 * navigator.product -> 'ReactNative' 39028 * nativescript 39029 * navigator.product -> 'NativeScript' or 'NS' 39030 * 39031 * @returns {boolean} 39032 */ 39033const hasStandardBrowserEnv = hasBrowserEnv && 39034 (!_navigator || ['ReactNative', 'NativeScript', 'NS'].indexOf(_navigator.product) < 0); 39035 39036/** 39037 * Determine if we're running in a standard browser webWorker environment 39038 * 39039 * Although the `isStandardBrowserEnv` method indicates that 39040 * `allows axios to run in a web worker`, the WebWorker will still be 39041 * filtered out due to its judgment standard 39042 * `typeof window !== 'undefined' && typeof document !== 'undefined'`. 39043 * This leads to a problem when axios post `FormData` in webWorker 39044 */ 39045const hasStandardBrowserWebWorkerEnv = (() => { 39046 return ( 39047 typeof WorkerGlobalScope !== 'undefined' && 39048 // eslint-disable-next-line no-undef 39049 self instanceof WorkerGlobalScope && 39050 typeof self.importScripts === 'function' 39051 ); 39052})(); 39053 39054const origin = hasBrowserEnv && window.location.href || 'http://localhost'; 39055 39056 39057 39058 39059/***/ }), 39060
vendor: 1,070 bytes, lines 39061-39084
39061/***/ "./node_modules/axios/lib/platform/index.js": 39062/*!**************************************************!*\ 39063 !*** ./node_modules/axios/lib/platform/index.js ***! 39064 \**************************************************/ 39065/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 39066 39067"use strict"; 39068__webpack_require__.r(__webpack_exports__); 39069/* harmony export */ __webpack_require__.d(__webpack_exports__, { 39070/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 39071/* harmony export */ }); 39072/* harmony import */ var _node_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./node/index.js */ "./node_modules/axios/lib/platform/browser/index.js"); 39073/* harmony import */ var _common_utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common/utils.js */ "./node_modules/axios/lib/platform/common/utils.js"); 39074 39075 39076 39077/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({ 39078 ..._common_utils_js__WEBPACK_IMPORTED_MODULE_0__, 39079 ..._node_index_js__WEBPACK_IMPORTED_MODULE_1__["default"] 39080}); 39081 39082 39083/***/ }), 39084
vendor: 19,116 bytes, lines 39085-39839
39085/***/ "./node_modules/axios/lib/utils.js": 39086/*!*****************************************!*\ 39087 !*** ./node_modules/axios/lib/utils.js ***! 39088 \*****************************************/ 39089/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 39090 39091"use strict"; 39092__webpack_require__.r(__webpack_exports__); 39093/* harmony export */ __webpack_require__.d(__webpack_exports__, { 39094/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 39095/* harmony export */ }); 39096/* harmony import */ var _helpers_bind_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./helpers/bind.js */ "./node_modules/axios/lib/helpers/bind.js"); 39097/* provided dependency */ var process = __webpack_require__(/*! process/browser.js */ "./node_modules/process/browser.js"); 39098 39099 39100 39101 39102// utils is a library of generic helper functions non-specific to axios 39103 39104const {toString} = Object.prototype; 39105const {getPrototypeOf} = Object; 39106 39107const kindOf = (cache => thing => { 39108 const str = toString.call(thing); 39109 return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase()); 39110})(Object.create(null)); 39111 39112const kindOfTest = (type) => { 39113 type = type.toLowerCase(); 39114 return (thing) => kindOf(thing) === type 39115} 39116 39117const typeOfTest = type => thing => typeof thing === type; 39118 39119/** 39120 * Determine if a value is an Array 39121 * 39122 * @param {Object} val The value to test 39123 * 39124 * @returns {boolean} True if value is an Array, otherwise false 39125 */ 39126const {isArray} = Array; 39127 39128/** 39129 * Determine if a value is undefined 39130 * 39131 * @param {*} val The value to test 39132 * 39133 * @returns {boolean} True if the value is undefined, otherwise false 39134 */ 39135const isUndefined = typeOfTest('undefined'); 39136 39137/** 39138 * Determine if a value is a Buffer 39139 * 39140 * @param {*} val The value to test 39141 * 39142 * @returns {boolean} True if value is a Buffer, otherwise false 39143 */ 39144function isBuffer(val) { 39145 return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) 39146 && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val); 39147} 39148 39149/** 39150 * Determine if a value is an ArrayBuffer 39151 * 39152 * @param {*} val The value to test 39153 * 39154 * @returns {boolean} True if value is an ArrayBuffer, otherwise false 39155 */ 39156const isArrayBuffer = kindOfTest('ArrayBuffer'); 39157 39158 39159/** 39160 * Determine if a value is a view on an ArrayBuffer 39161 * 39162 * @param {*} val The value to test 39163 * 39164 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false 39165 */ 39166function isArrayBufferView(val) { 39167 let result; 39168 if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) { 39169 result = ArrayBuffer.isView(val); 39170 } else { 39171 result = (val) && (val.buffer) && (isArrayBuffer(val.buffer)); 39172 } 39173 return result; 39174} 39175 39176/** 39177 * Determine if a value is a String 39178 * 39179 * @param {*} val The value to test 39180 * 39181 * @returns {boolean} True if value is a String, otherwise false 39182 */ 39183const isString = typeOfTest('string'); 39184 39185/** 39186 * Determine if a value is a Function 39187 * 39188 * @param {*} val The value to test 39189 * @returns {boolean} True if value is a Function, otherwise false 39190 */ 39191const isFunction = typeOfTest('function'); 39192 39193/** 39194 * Determine if a value is a Number 39195 * 39196 * @param {*} val The value to test 39197 * 39198 * @returns {boolean} True if value is a Number, otherwise false 39199 */ 39200const isNumber = typeOfTest('number'); 39201 39202/** 39203 * Determine if a value is an Object 39204 * 39205 * @param {*} thing The value to test 39206 * 39207 * @returns {boolean} True if value is an Object, otherwise false 39208 */ 39209const isObject = (thing) => thing !== null && typeof thing === 'object'; 39210 39211/** 39212 * Determine if a value is a Boolean 39213 * 39214 * @param {*} thing The value to test 39215 * @returns {boolean} True if value is a Boolean, otherwise false 39216 */ 39217const isBoolean = thing => thing === true || thing === false; 39218 39219/** 39220 * Determine if a value is a plain Object 39221 * 39222 * @param {*} val The value to test 39223 * 39224 * @returns {boolean} True if value is a plain Object, otherwise false 39225 */ 39226const isPlainObject = (val) => { 39227 if (kindOf(val) !== 'object') { 39228 return false; 39229 } 39230 39231 const prototype = getPrototypeOf(val); 39232 return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val); 39233} 39234 39235/** 39236 * Determine if a value is a Date 39237 * 39238 * @param {*} val The value to test 39239 * 39240 * @returns {boolean} True if value is a Date, otherwise false 39241 */ 39242const isDate = kindOfTest('Date'); 39243 39244/** 39245 * Determine if a value is a File 39246 * 39247 * @param {*} val The value to test 39248 * 39249 * @returns {boolean} True if value is a File, otherwise false 39250 */ 39251const isFile = kindOfTest('File'); 39252 39253/** 39254 * Determine if a value is a Blob 39255 * 39256 * @param {*} val The value to test 39257 * 39258 * @returns {boolean} True if value is a Blob, otherwise false 39259 */ 39260const isBlob = kindOfTest('Blob'); 39261 39262/** 39263 * Determine if a value is a FileList 39264 * 39265 * @param {*} val The value to test 39266 * 39267 * @returns {boolean} True if value is a File, otherwise false 39268 */ 39269const isFileList = kindOfTest('FileList'); 39270 39271/** 39272 * Determine if a value is a Stream 39273 * 39274 * @param {*} val The value to test 39275 * 39276 * @returns {boolean} True if value is a Stream, otherwise false 39277 */ 39278const isStream = (val) => isObject(val) && isFunction(val.pipe); 39279 39280/** 39281 * Determine if a value is a FormData 39282 * 39283 * @param {*} thing The value to test 39284 * 39285 * @returns {boolean} True if value is an FormData, otherwise false 39286 */ 39287const isFormData = (thing) => { 39288 let kind; 39289 return thing && ( 39290 (typeof FormData === 'function' && thing instanceof FormData) || ( 39291 isFunction(thing.append) && ( 39292 (kind = kindOf(thing)) === 'formdata' || 39293 // detect form-data instance 39294 (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]') 39295 ) 39296 ) 39297 ) 39298} 39299 39300/** 39301 * Determine if a value is a URLSearchParams object 39302 * 39303 * @param {*} val The value to test 39304 * 39305 * @returns {boolean} True if value is a URLSearchParams object, otherwise false 39306 */ 39307const isURLSearchParams = kindOfTest('URLSearchParams'); 39308 39309const [isReadableStream, isRequest, isResponse, isHeaders] = ['ReadableStream', 'Request', 'Response', 'Headers'].map(kindOfTest); 39310 39311/** 39312 * Trim excess whitespace off the beginning and end of a string 39313 * 39314 * @param {String} str The String to trim 39315 * 39316 * @returns {String} The String freed of excess whitespace 39317 */ 39318const trim = (str) => str.trim ? 39319 str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''); 39320 39321/** 39322 * Iterate over an Array or an Object invoking a function for each item. 39323 * 39324 * If `obj` is an Array callback will be called passing 39325 * the value, index, and complete array for each item. 39326 * 39327 * If 'obj' is an Object callback will be called passing 39328 * the value, key, and complete object for each property. 39329 * 39330 * @param {Object|Array} obj The object to iterate 39331 * @param {Function} fn The callback to invoke for each item 39332 * 39333 * @param {Boolean} [allOwnKeys = false] 39334 * @returns {any} 39335 */ 39336function forEach(obj, fn, {allOwnKeys = false} = {}) { 39337 // Don't bother if no value provided 39338 if (obj === null || typeof obj === 'undefined') { 39339 return; 39340 } 39341 39342 let i; 39343 let l; 39344 39345 // Force an array if not already something iterable 39346 if (typeof obj !== 'object') { 39347 /*eslint no-param-reassign:0*/ 39348 obj = [obj]; 39349 } 39350 39351 if (isArray(obj)) { 39352 // Iterate over array values 39353 for (i = 0, l = obj.length; i < l; i++) { 39354 fn.call(null, obj[i], i, obj); 39355 } 39356 } else { 39357 // Iterate over object keys 39358 const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj); 39359 const len = keys.length; 39360 let key; 39361 39362 for (i = 0; i < len; i++) { 39363 key = keys[i]; 39364 fn.call(null, obj[key], key, obj); 39365 } 39366 } 39367} 39368 39369function findKey(obj, key) { 39370 key = key.toLowerCase(); 39371 const keys = Object.keys(obj); 39372 let i = keys.length; 39373 let _key; 39374 while (i-- > 0) { 39375 _key = keys[i]; 39376 if (key === _key.toLowerCase()) { 39377 return _key; 39378 } 39379 } 39380 return null; 39381} 39382 39383const _global = (() => { 39384 /*eslint no-undef:0*/ 39385 if (typeof globalThis !== "undefined") return globalThis; 39386 return typeof self !== "undefined" ? self : (typeof window !== 'undefined' ? window : global) 39387})(); 39388 39389const isContextDefined = (context) => !isUndefined(context) && context !== _global; 39390 39391/** 39392 * Accepts varargs expecting each argument to be an object, then 39393 * immutably merges the properties of each object and returns result. 39394 * 39395 * When multiple objects contain the same key the later object in 39396 * the arguments list will take precedence. 39397 * 39398 * Example: 39399 * 39400 * ```js 39401 * var result = merge({foo: 123}, {foo: 456}); 39402 * console.log(result.foo); // outputs 456 39403 * ``` 39404 * 39405 * @param {Object} obj1 Object to merge 39406 * 39407 * @returns {Object} Result of all merge properties 39408 */ 39409function merge(/* obj1, obj2, obj3, ... */) { 39410 const {caseless} = isContextDefined(this) && this || {}; 39411 const result = {}; 39412 const assignValue = (val, key) => { 39413 const targetKey = caseless && findKey(result, key) || key; 39414 if (isPlainObject(result[targetKey]) && isPlainObject(val)) { 39415 result[targetKey] = merge(result[targetKey], val); 39416 } else if (isPlainObject(val)) { 39417 result[targetKey] = merge({}, val); 39418 } else if (isArray(val)) { 39419 result[targetKey] = val.slice(); 39420 } else { 39421 result[targetKey] = val; 39422 } 39423 } 39424 39425 for (let i = 0, l = arguments.length; i < l; i++) { 39426 arguments[i] && forEach(arguments[i], assignValue); 39427 } 39428 return result; 39429} 39430 39431/** 39432 * Extends object a by mutably adding to it the properties of object b. 39433 * 39434 * @param {Object} a The object to be extended 39435 * @param {Object} b The object to copy properties from 39436 * @param {Object} thisArg The object to bind function to 39437 * 39438 * @param {Boolean} [allOwnKeys] 39439 * @returns {Object} The resulting value of object a 39440 */ 39441const extend = (a, b, thisArg, {allOwnKeys}= {}) => { 39442 forEach(b, (val, key) => { 39443 if (thisArg && isFunction(val)) { 39444 a[key] = (0,_helpers_bind_js__WEBPACK_IMPORTED_MODULE_0__["default"])(val, thisArg); 39445 } else { 39446 a[key] = val; 39447 } 39448 }, {allOwnKeys}); 39449 return a; 39450} 39451 39452/** 39453 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM) 39454 * 39455 * @param {string} content with BOM 39456 * 39457 * @returns {string} content value without BOM 39458 */ 39459const stripBOM = (content) => { 39460 if (content.charCodeAt(0) === 0xFEFF) { 39461 content = content.slice(1); 39462 } 39463 return content; 39464} 39465 39466/** 39467 * Inherit the prototype methods from one constructor into another 39468 * @param {function} constructor 39469 * @param {function} superConstructor 39470 * @param {object} [props] 39471 * @param {object} [descriptors] 39472 * 39473 * @returns {void} 39474 */ 39475const inherits = (constructor, superConstructor, props, descriptors) => { 39476 constructor.prototype = Object.create(superConstructor.prototype, descriptors); 39477 constructor.prototype.constructor = constructor; 39478 Object.defineProperty(constructor, 'super', { 39479 value: superConstructor.prototype 39480 }); 39481 props && Object.assign(constructor.prototype, props); 39482} 39483 39484/** 39485 * Resolve object with deep prototype chain to a flat object 39486 * @param {Object} sourceObj source object 39487 * @param {Object} [destObj] 39488 * @param {Function|Boolean} [filter] 39489 * @param {Function} [propFilter] 39490 * 39491 * @returns {Object} 39492 */ 39493const toFlatObject = (sourceObj, destObj, filter, propFilter) => { 39494 let props; 39495 let i; 39496 let prop; 39497 const merged = {}; 39498 39499 destObj = destObj || {}; 39500 // eslint-disable-next-line no-eq-null,eqeqeq 39501 if (sourceObj == null) return destObj; 39502 39503 do { 39504 props = Object.getOwnPropertyNames(sourceObj); 39505 i = props.length; 39506 while (i-- > 0) { 39507 prop = props[i]; 39508 if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) { 39509 destObj[prop] = sourceObj[prop]; 39510 merged[prop] = true; 39511 } 39512 } 39513 sourceObj = filter !== false && getPrototypeOf(sourceObj); 39514 } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype); 39515 39516 return destObj; 39517} 39518 39519/** 39520 * Determines whether a string ends with the characters of a specified string 39521 * 39522 * @param {String} str 39523 * @param {String} searchString 39524 * @param {Number} [position= 0] 39525 * 39526 * @returns {boolean} 39527 */ 39528const endsWith = (str, searchString, position) => { 39529 str = String(str); 39530 if (position === undefined || position > str.length) { 39531 position = str.length; 39532 } 39533 position -= searchString.length; 39534 const lastIndex = str.indexOf(searchString, position); 39535 return lastIndex !== -1 && lastIndex === position; 39536} 39537 39538 39539/** 39540 * Returns new array from array like object or null if failed 39541 * 39542 * @param {*} [thing] 39543 * 39544 * @returns {?Array} 39545 */ 39546const toArray = (thing) => { 39547 if (!thing) return null; 39548 if (isArray(thing)) return thing; 39549 let i = thing.length; 39550 if (!isNumber(i)) return null; 39551 const arr = new Array(i); 39552 while (i-- > 0) { 39553 arr[i] = thing[i]; 39554 } 39555 return arr; 39556} 39557 39558/** 39559 * Checking if the Uint8Array exists and if it does, it returns a function that checks if the 39560 * thing passed in is an instance of Uint8Array 39561 * 39562 * @param {TypedArray} 39563 * 39564 * @returns {Array} 39565 */ 39566// eslint-disable-next-line func-names 39567const isTypedArray = (TypedArray => { 39568 // eslint-disable-next-line func-names 39569 return thing => { 39570 return TypedArray && thing instanceof TypedArray; 39571 }; 39572})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array)); 39573 39574/** 39575 * For each entry in the object, call the function with the key and value. 39576 * 39577 * @param {Object<any, any>} obj - The object to iterate over. 39578 * @param {Function} fn - The function to call for each entry. 39579 * 39580 * @returns {void} 39581 */ 39582const forEachEntry = (obj, fn) => { 39583 const generator = obj && obj[Symbol.iterator]; 39584 39585 const iterator = generator.call(obj); 39586 39587 let result; 39588 39589 while ((result = iterator.next()) && !result.done) { 39590 const pair = result.value; 39591 fn.call(obj, pair[0], pair[1]); 39592 } 39593} 39594 39595/** 39596 * It takes a regular expression and a string, and returns an array of all the matches 39597 * 39598 * @param {string} regExp - The regular expression to match against. 39599 * @param {string} str - The string to search. 39600 * 39601 * @returns {Array<boolean>} 39602 */ 39603const matchAll = (regExp, str) => { 39604 let matches; 39605 const arr = []; 39606 39607 while ((matches = regExp.exec(str)) !== null) { 39608 arr.push(matches); 39609 } 39610 39611 return arr; 39612} 39613 39614/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */ 39615const isHTMLForm = kindOfTest('HTMLFormElement'); 39616 39617const toCamelCase = str => { 39618 return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, 39619 function replacer(m, p1, p2) { 39620 return p1.toUpperCase() + p2; 39621 } 39622 ); 39623}; 39624 39625/* Creating a function that will check if an object has a property. */ 39626const hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype); 39627 39628/** 39629 * Determine if a value is a RegExp object 39630 * 39631 * @param {*} val The value to test 39632 * 39633 * @returns {boolean} True if value is a RegExp object, otherwise false 39634 */ 39635const isRegExp = kindOfTest('RegExp'); 39636 39637const reduceDescriptors = (obj, reducer) => { 39638 const descriptors = Object.getOwnPropertyDescriptors(obj); 39639 const reducedDescriptors = {}; 39640 39641 forEach(descriptors, (descriptor, name) => { 39642 let ret; 39643 if ((ret = reducer(descriptor, name, obj)) !== false) { 39644 reducedDescriptors[name] = ret || descriptor; 39645 } 39646 }); 39647 39648 Object.defineProperties(obj, reducedDescriptors); 39649} 39650 39651/** 39652 * Makes all methods read-only 39653 * @param {Object} obj 39654 */ 39655 39656const freezeMethods = (obj) => { 39657 reduceDescriptors(obj, (descriptor, name) => { 39658 // skip restricted props in strict mode 39659 if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) { 39660 return false; 39661 } 39662 39663 const value = obj[name]; 39664 39665 if (!isFunction(value)) return; 39666 39667 descriptor.enumerable = false; 39668 39669 if ('writable' in descriptor) { 39670 descriptor.writable = false; 39671 return; 39672 } 39673 39674 if (!descriptor.set) { 39675 descriptor.set = () => { 39676 throw Error('Can not rewrite read-only method \'' + name + '\''); 39677 }; 39678 } 39679 }); 39680} 39681 39682const toObjectSet = (arrayOrString, delimiter) => { 39683 const obj = {}; 39684 39685 const define = (arr) => { 39686 arr.forEach(value => { 39687 obj[value] = true; 39688 }); 39689 } 39690 39691 isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter)); 39692 39693 return obj; 39694} 39695 39696const noop = () => {} 39697 39698const toFiniteNumber = (value, defaultValue) => { 39699 return value != null && Number.isFinite(value = +value) ? value : defaultValue; 39700} 39701 39702/** 39703 * If the thing is a FormData object, return true, otherwise return false. 39704 * 39705 * @param {unknown} thing - The thing to check. 39706 * 39707 * @returns {boolean} 39708 */ 39709function isSpecCompliantForm(thing) { 39710 return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator]); 39711} 39712 39713const toJSONObject = (obj) => { 39714 const stack = new Array(10); 39715 39716 const visit = (source, i) => { 39717 39718 if (isObject(source)) { 39719 if (stack.indexOf(source) >= 0) { 39720 return; 39721 } 39722 39723 if(!('toJSON' in source)) { 39724 stack[i] = source; 39725 const target = isArray(source) ? [] : {}; 39726 39727 forEach(source, (value, key) => { 39728 const reducedValue = visit(value, i + 1); 39729 !isUndefined(reducedValue) && (target[key] = reducedValue); 39730 }); 39731 39732 stack[i] = undefined; 39733 39734 return target; 39735 } 39736 } 39737 39738 return source; 39739 } 39740 39741 return visit(obj, 0); 39742} 39743 39744const isAsyncFn = kindOfTest('AsyncFunction'); 39745 39746const isThenable = (thing) => 39747 thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch); 39748 39749// original code 39750// https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34 39751 39752const _setImmediate = ((setImmediateSupported, postMessageSupported) => { 39753 if (setImmediateSupported) { 39754 return setImmediate; 39755 } 39756 39757 return postMessageSupported ? ((token, callbacks) => { 39758 _global.addEventListener("message", ({source, data}) => { 39759 if (source === _global && data === token) { 39760 callbacks.length && callbacks.shift()(); 39761 } 39762 }, false); 39763 39764 return (cb) => { 39765 callbacks.push(cb); 39766 _global.postMessage(token, "*"); 39767 } 39768 })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb); 39769})( 39770 typeof setImmediate === 'function', 39771 isFunction(_global.postMessage) 39772); 39773 39774const asap = typeof queueMicrotask !== 'undefined' ? 39775 queueMicrotask.bind(_global) : ( typeof process !== 'undefined' && process.nextTick || _setImmediate); 39776 39777// ********************* 39778 39779/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({ 39780 isArray, 39781 isArrayBuffer, 39782 isBuffer, 39783 isFormData, 39784 isArrayBufferView, 39785 isString, 39786 isNumber, 39787 isBoolean, 39788 isObject, 39789 isPlainObject, 39790 isReadableStream, 39791 isRequest, 39792 isResponse, 39793 isHeaders, 39794 isUndefined, 39795 isDate, 39796 isFile, 39797 isBlob, 39798 isRegExp, 39799 isFunction, 39800 isStream, 39801 isURLSearchParams, 39802 isTypedArray, 39803 isFileList, 39804 forEach, 39805 merge, 39806 extend, 39807 trim, 39808 stripBOM, 39809 inherits, 39810 toFlatObject, 39811 kindOf, 39812 kindOfTest, 39813 endsWith, 39814 toArray, 39815 forEachEntry, 39816 matchAll, 39817 isHTMLForm, 39818 hasOwnProperty, 39819 hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection 39820 reduceDescriptors, 39821 freezeMethods, 39822 toObjectSet, 39823 toCamelCase, 39824 noop, 39825 toFiniteNumber, 39826 findKey, 39827 global: _global, 39828 isContextDefined, 39829 isSpecCompliantForm, 39830 toJSONObject, 39831 isAsyncFn, 39832 isThenable, 39833 setImmediate: _setImmediate, 39834 asap 39835}); 39836 39837 39838/***/ }), 39839
vendor: 926 bytes, lines 39840-39856
39840/***/ "./node_modules/mitt/dist/mitt.mjs": 39841/*!*****************************************!*\ 39842 !*** ./node_modules/mitt/dist/mitt.mjs ***! 39843 \*****************************************/ 39844/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 39845 39846"use strict"; 39847__webpack_require__.r(__webpack_exports__); 39848/* harmony export */ __webpack_require__.d(__webpack_exports__, { 39849/* harmony export */ "default": () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__) 39850/* harmony export */ }); 39851/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(n){return{all:n=n||new Map,on:function(t,e){var i=n.get(t);i?i.push(e):n.set(t,[e])},off:function(t,e){var i=n.get(t);i&&(e?i.splice(i.indexOf(e)>>>0,1):n.set(t,[]))},emit:function(t,e){var i=n.get(t);i&&i.slice().map(function(n){n(e)}),(i=n.get("*"))&&i.slice().map(function(n){n(t,e)})}}} 39852//# sourceMappingURL=mitt.mjs.map 39853 39854 39855/***/ }), 39856
vendor: 79,807 bytes, lines 39857-41931
39857/***/ "./node_modules/pinia/dist/pinia.mjs": 39858/*!*******************************************!*\ 39859 !*** ./node_modules/pinia/dist/pinia.mjs ***! 39860 \*******************************************/ 39861/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 39862 39863"use strict"; 39864__webpack_require__.r(__webpack_exports__); 39865/* harmony export */ __webpack_require__.d(__webpack_exports__, { 39866/* harmony export */ MutationType: () => (/* binding */ MutationType), 39867/* harmony export */ PiniaVuePlugin: () => (/* binding */ PiniaVuePlugin), 39868/* harmony export */ acceptHMRUpdate: () => (/* binding */ acceptHMRUpdate), 39869/* harmony export */ createPinia: () => (/* binding */ createPinia), 39870/* harmony export */ defineStore: () => (/* binding */ defineStore), 39871/* harmony export */ disposePinia: () => (/* binding */ disposePinia), 39872/* harmony export */ getActivePinia: () => (/* binding */ getActivePinia), 39873/* harmony export */ mapActions: () => (/* binding */ mapActions), 39874/* harmony export */ mapGetters: () => (/* binding */ mapGetters), 39875/* harmony export */ mapState: () => (/* binding */ mapState), 39876/* harmony export */ mapStores: () => (/* binding */ mapStores), 39877/* harmony export */ mapWritableState: () => (/* binding */ mapWritableState), 39878/* harmony export */ setActivePinia: () => (/* binding */ setActivePinia), 39879/* harmony export */ setMapStoreSuffix: () => (/* binding */ setMapStoreSuffix), 39880/* harmony export */ shouldHydrate: () => (/* binding */ shouldHydrate), 39881/* harmony export */ skipHydrate: () => (/* binding */ skipHydrate), 39882/* harmony export */ storeToRefs: () => (/* binding */ storeToRefs) 39883/* harmony export */ }); 39884/* harmony import */ var vue_demi__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue-demi */ "./node_modules/vue-demi/lib/index.mjs"); 39885/* harmony import */ var _vue_devtools_api__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/devtools-api */ "./node_modules/@vue/devtools-api/lib/esm/index.js"); 39886/*! 39887 * pinia v2.3.1 39888 * (c) 2025 Eduardo San Martin Morote 39889 * @license MIT 39890 */ 39891 39892 39893 39894/** 39895 * setActivePinia must be called to handle SSR at the top of functions like 39896 * `fetch`, `setup`, `serverPrefetch` and others 39897 */ 39898let activePinia; 39899/** 39900 * Sets or unsets the active pinia. Used in SSR and internally when calling 39901 * actions and getters 39902 * 39903 * @param pinia - Pinia instance 39904 */ 39905// @ts-expect-error: cannot constrain the type of the return 39906const setActivePinia = (pinia) => (activePinia = pinia); 39907/** 39908 * Get the currently active pinia if there is any. 39909 */ 39910const getActivePinia = () => ((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.hasInjectionContext)() && (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.inject)(piniaSymbol)) || activePinia; 39911const piniaSymbol = (( true) ? Symbol('pinia') : /* istanbul ignore next */ 0); 39912 39913function isPlainObject( 39914// eslint-disable-next-line @typescript-eslint/no-explicit-any 39915o) { 39916 return (o && 39917 typeof o === 'object' && 39918 Object.prototype.toString.call(o) === '[object Object]' && 39919 typeof o.toJSON !== 'function'); 39920} 39921// type DeepReadonly<T> = { readonly [P in keyof T]: DeepReadonly<T[P]> } 39922// TODO: can we change these to numbers? 39923/** 39924 * Possible types for SubscriptionCallback 39925 */ 39926var MutationType; 39927(function (MutationType) { 39928 /** 39929 * Direct mutation of the state: 39930 * 39931 * - `store.name = 'new name'` 39932 * - `store.$state.name = 'new name'` 39933 * - `store.list.push('new item')` 39934 */ 39935 MutationType["direct"] = "direct"; 39936 /** 39937 * Mutated the state with `$patch` and an object 39938 * 39939 * - `store.$patch({ name: 'newName' })` 39940 */ 39941 MutationType["patchObject"] = "patch object"; 39942 /** 39943 * Mutated the state with `$patch` and a function 39944 * 39945 * - `store.$patch(state => state.name = 'newName')` 39946 */ 39947 MutationType["patchFunction"] = "patch function"; 39948 // maybe reset? for $state = {} and $reset 39949})(MutationType || (MutationType = {})); 39950 39951const IS_CLIENT = typeof window !== 'undefined'; 39952 39953/* 39954 * FileSaver.js A saveAs() FileSaver implementation. 39955 * 39956 * Originally by Eli Grey, adapted as an ESM module by Eduardo San Martin 39957 * Morote. 39958 * 39959 * License : MIT 39960 */ 39961// The one and only way of getting global scope in all environments 39962// https://stackoverflow.com/q/3277182/1008999 39963const _global = /*#__PURE__*/ (() => typeof window === 'object' && window.window === window 39964 ? window 39965 : typeof self === 'object' && self.self === self 39966 ? self 39967 : typeof global === 'object' && global.global === global 39968 ? global 39969 : typeof globalThis === 'object' 39970 ? globalThis 39971 : { HTMLElement: null })(); 39972function bom(blob, { autoBom = false } = {}) { 39973 // prepend BOM for UTF-8 XML and text/* types (including HTML) 39974 // note: your browser will automatically convert UTF-16 U+FEFF to EF BB BF 39975 if (autoBom && 39976 /^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(blob.type)) { 39977 return new Blob([String.fromCharCode(0xfeff), blob], { type: blob.type }); 39978 } 39979 return blob; 39980} 39981function download(url, name, opts) { 39982 const xhr = new XMLHttpRequest(); 39983 xhr.open('GET', url); 39984 xhr.responseType = 'blob'; 39985 xhr.onload = function () { 39986 saveAs(xhr.response, name, opts); 39987 }; 39988 xhr.onerror = function () { 39989 console.error('could not download file'); 39990 }; 39991 xhr.send(); 39992} 39993function corsEnabled(url) { 39994 const xhr = new XMLHttpRequest(); 39995 // use sync to avoid popup blocker 39996 xhr.open('HEAD', url, false); 39997 try { 39998 xhr.send(); 39999 } 40000 catch (e) { } 40001 return xhr.status >= 200 && xhr.status <= 299; 40002} 40003// `a.click()` doesn't work for all browsers (#465) 40004function click(node) { 40005 try { 40006 node.dispatchEvent(new MouseEvent('click')); 40007 } 40008 catch (e) { 40009 const evt = document.createEvent('MouseEvents'); 40010 evt.initMouseEvent('click', true, true, window, 0, 0, 0, 80, 20, false, false, false, false, 0, null); 40011 node.dispatchEvent(evt); 40012 } 40013} 40014const _navigator = typeof navigator === 'object' ? navigator : { userAgent: '' }; 40015// Detect WebView inside a native macOS app by ruling out all browsers 40016// We just need to check for 'Safari' because all other browsers (besides Firefox) include that too 40017// https://www.whatismybrowser.com/guides/the-latest-user-agent/macos 40018const isMacOSWebView = /*#__PURE__*/ (() => /Macintosh/.test(_navigator.userAgent) && 40019 /AppleWebKit/.test(_navigator.userAgent) && 40020 !/Safari/.test(_navigator.userAgent))(); 40021const saveAs = !IS_CLIENT 40022 ? () => { } // noop 40023 : // Use download attribute first if possible (#193 Lumia mobile) unless this is a macOS WebView or mini program 40024 typeof HTMLAnchorElement !== 'undefined' && 40025 'download' in HTMLAnchorElement.prototype && 40026 !isMacOSWebView 40027 ? downloadSaveAs 40028 : // Use msSaveOrOpenBlob as a second approach 40029 'msSaveOrOpenBlob' in _navigator 40030 ? msSaveAs 40031 : // Fallback to using FileReader and a popup 40032 fileSaverSaveAs; 40033function downloadSaveAs(blob, name = 'download', opts) { 40034 const a = document.createElement('a'); 40035 a.download = name; 40036 a.rel = 'noopener'; // tabnabbing 40037 // TODO: detect chrome extensions & packaged apps 40038 // a.target = '_blank' 40039 if (typeof blob === 'string') { 40040 // Support regular links 40041 a.href = blob; 40042 if (a.origin !== location.origin) { 40043 if (corsEnabled(a.href)) { 40044 download(blob, name, opts); 40045 } 40046 else { 40047 a.target = '_blank'; 40048 click(a); 40049 } 40050 } 40051 else { 40052 click(a); 40053 } 40054 } 40055 else { 40056 // Support blobs 40057 a.href = URL.createObjectURL(blob); 40058 setTimeout(function () { 40059 URL.revokeObjectURL(a.href); 40060 }, 4e4); // 40s 40061 setTimeout(function () { 40062 click(a); 40063 }, 0); 40064 } 40065} 40066function msSaveAs(blob, name = 'download', opts) { 40067 if (typeof blob === 'string') { 40068 if (corsEnabled(blob)) { 40069 download(blob, name, opts); 40070 } 40071 else { 40072 const a = document.createElement('a'); 40073 a.href = blob; 40074 a.target = '_blank'; 40075 setTimeout(function () { 40076 click(a); 40077 }); 40078 } 40079 } 40080 else { 40081 // @ts-ignore: works on windows 40082 navigator.msSaveOrOpenBlob(bom(blob, opts), name); 40083 } 40084} 40085function fileSaverSaveAs(blob, name, opts, popup) { 40086 // Open a popup immediately do go around popup blocker 40087 // Mostly only available on user interaction and the fileReader is async so... 40088 popup = popup || open('', '_blank'); 40089 if (popup) { 40090 popup.document.title = popup.document.body.innerText = 'downloading...'; 40091 } 40092 if (typeof blob === 'string') 40093 return download(blob, name, opts); 40094 const force = blob.type === 'application/octet-stream'; 40095 const isSafari = /constructor/i.test(String(_global.HTMLElement)) || 'safari' in _global; 40096 const isChromeIOS = /CriOS\/[\d]+/.test(navigator.userAgent); 40097 if ((isChromeIOS || (force && isSafari) || isMacOSWebView) && 40098 typeof FileReader !== 'undefined') { 40099 // Safari doesn't allow downloading of blob URLs 40100 const reader = new FileReader(); 40101 reader.onloadend = function () { 40102 let url = reader.result; 40103 if (typeof url !== 'string') { 40104 popup = null; 40105 throw new Error('Wrong reader.result type'); 40106 } 40107 url = isChromeIOS 40108 ? url 40109 : url.replace(/^data:[^;]*;/, 'data:attachment/file;'); 40110 if (popup) { 40111 popup.location.href = url; 40112 } 40113 else { 40114 location.assign(url); 40115 } 40116 popup = null; // reverse-tabnabbing #460 40117 }; 40118 reader.readAsDataURL(blob); 40119 } 40120 else { 40121 const url = URL.createObjectURL(blob); 40122 if (popup) 40123 popup.location.assign(url); 40124 else 40125 location.href = url; 40126 popup = null; // reverse-tabnabbing #460 40127 setTimeout(function () { 40128 URL.revokeObjectURL(url); 40129 }, 4e4); // 40s 40130 } 40131} 40132 40133/** 40134 * Shows a toast or console.log 40135 * 40136 * @param message - message to log 40137 * @param type - different color of the tooltip 40138 */ 40139function toastMessage(message, type) { 40140 const piniaMessage = 'ð ' + message; 40141 if (typeof __VUE_DEVTOOLS_TOAST__ === 'function') { 40142 // No longer available :( 40143 __VUE_DEVTOOLS_TOAST__(piniaMessage, type); 40144 } 40145 else if (type === 'error') { 40146 console.error(piniaMessage); 40147 } 40148 else if (type === 'warn') { 40149 console.warn(piniaMessage); 40150 } 40151 else { 40152 console.log(piniaMessage); 40153 } 40154} 40155function isPinia(o) { 40156 return '_a' in o && 'install' in o; 40157} 40158 40159/** 40160 * This file contain devtools actions, they are not Pinia actions. 40161 */ 40162// --- 40163function checkClipboardAccess() { 40164 if (!('clipboard' in navigator)) { 40165 toastMessage(`Your browser doesn't support the Clipboard API`, 'error'); 40166 return true; 40167 } 40168} 40169function checkNotFocusedError(error) { 40170 if (error instanceof Error && 40171 error.message.toLowerCase().includes('document is not focused')) { 40172 toastMessage('You need to activate the "Emulate a focused page" setting in the "Rendering" panel of devtools.', 'warn'); 40173 return true; 40174 } 40175 return false; 40176} 40177async function actionGlobalCopyState(pinia) { 40178 if (checkClipboardAccess()) 40179 return; 40180 try { 40181 await navigator.clipboard.writeText(JSON.stringify(pinia.state.value)); 40182 toastMessage('Global state copied to clipboard.'); 40183 } 40184 catch (error) { 40185 if (checkNotFocusedError(error)) 40186 return; 40187 toastMessage(`Failed to serialize the state. Check the console for more details.`, 'error'); 40188 console.error(error); 40189 } 40190} 40191async function actionGlobalPasteState(pinia) { 40192 if (checkClipboardAccess()) 40193 return; 40194 try { 40195 loadStoresState(pinia, JSON.parse(await navigator.clipboard.readText())); 40196 toastMessage('Global state pasted from clipboard.'); 40197 } 40198 catch (error) { 40199 if (checkNotFocusedError(error)) 40200 return; 40201 toastMessage(`Failed to deserialize the state from clipboard. Check the console for more details.`, 'error'); 40202 console.error(error); 40203 } 40204} 40205async function actionGlobalSaveState(pinia) { 40206 try { 40207 saveAs(new Blob([JSON.stringify(pinia.state.value)], { 40208 type: 'text/plain;charset=utf-8', 40209 }), 'pinia-state.json'); 40210 } 40211 catch (error) { 40212 toastMessage(`Failed to export the state as JSON. Check the console for more details.`, 'error'); 40213 console.error(error); 40214 } 40215} 40216let fileInput; 40217function getFileOpener() { 40218 if (!fileInput) { 40219 fileInput = document.createElement('input'); 40220 fileInput.type = 'file'; 40221 fileInput.accept = '.json'; 40222 } 40223 function openFile() { 40224 return new Promise((resolve, reject) => { 40225 fileInput.onchange = async () => { 40226 const files = fileInput.files; 40227 if (!files) 40228 return resolve(null); 40229 const file = files.item(0); 40230 if (!file) 40231 return resolve(null); 40232 return resolve({ text: await file.text(), file }); 40233 }; 40234 // @ts-ignore: TODO: changed from 4.3 to 4.4 40235 fileInput.oncancel = () => resolve(null); 40236 fileInput.onerror = reject; 40237 fileInput.click(); 40238 }); 40239 } 40240 return openFile; 40241} 40242async function actionGlobalOpenStateFile(pinia) { 40243 try { 40244 const open = getFileOpener(); 40245 const result = await open(); 40246 if (!result) 40247 return; 40248 const { text, file } = result; 40249 loadStoresState(pinia, JSON.parse(text)); 40250 toastMessage(`Global state imported from "${file.name}".`); 40251 } 40252 catch (error) { 40253 toastMessage(`Failed to import the state from JSON. Check the console for more details.`, 'error'); 40254 console.error(error); 40255 } 40256} 40257function loadStoresState(pinia, state) { 40258 for (const key in state) { 40259 const storeState = pinia.state.value[key]; 40260 // store is already instantiated, patch it 40261 if (storeState) { 40262 Object.assign(storeState, state[key]); 40263 } 40264 else { 40265 // store is not instantiated, set the initial state 40266 pinia.state.value[key] = state[key]; 40267 } 40268 } 40269} 40270 40271function formatDisplay(display) { 40272 return { 40273 _custom: { 40274 display, 40275 }, 40276 }; 40277} 40278const PINIA_ROOT_LABEL = 'ð Pinia (root)'; 40279const PINIA_ROOT_ID = '_root'; 40280function formatStoreForInspectorTree(store) { 40281 return isPinia(store) 40282 ? { 40283 id: PINIA_ROOT_ID, 40284 label: PINIA_ROOT_LABEL, 40285 } 40286 : { 40287 id: store.$id, 40288 label: store.$id, 40289 }; 40290} 40291function formatStoreForInspectorState(store) { 40292 if (isPinia(store)) { 40293 const storeNames = Array.from(store._s.keys()); 40294 const storeMap = store._s; 40295 const state = { 40296 state: storeNames.map((storeId) => ({ 40297 editable: true, 40298 key: storeId, 40299 value: store.state.value[storeId], 40300 })), 40301 getters: storeNames 40302 .filter((id) => storeMap.get(id)._getters) 40303 .map((id) => { 40304 const store = storeMap.get(id); 40305 return { 40306 editable: false, 40307 key: id, 40308 value: store._getters.reduce((getters, key) => { 40309 getters[key] = store[key]; 40310 return getters; 40311 }, {}), 40312 }; 40313 }), 40314 }; 40315 return state; 40316 } 40317 const state = { 40318 state: Object.keys(store.$state).map((key) => ({ 40319 editable: true, 40320 key, 40321 value: store.$state[key], 40322 })), 40323 }; 40324 // avoid adding empty getters 40325 if (store._getters && store._getters.length) { 40326 state.getters = store._getters.map((getterName) => ({ 40327 editable: false, 40328 key: getterName, 40329 value: store[getterName], 40330 })); 40331 } 40332 if (store._customProperties.size) { 40333 state.customProperties = Array.from(store._customProperties).map((key) => ({ 40334 editable: true, 40335 key, 40336 value: store[key], 40337 })); 40338 } 40339 return state; 40340} 40341function formatEventData(events) { 40342 if (!events) 40343 return {}; 40344 if (Array.isArray(events)) { 40345 // TODO: handle add and delete for arrays and objects 40346 return events.reduce((data, event) => { 40347 data.keys.push(event.key); 40348 data.operations.push(event.type); 40349 data.oldValue[event.key] = event.oldValue; 40350 data.newValue[event.key] = event.newValue; 40351 return data; 40352 }, { 40353 oldValue: {}, 40354 keys: [], 40355 operations: [], 40356 newValue: {}, 40357 }); 40358 } 40359 else { 40360 return { 40361 operation: formatDisplay(events.type), 40362 key: formatDisplay(events.key), 40363 oldValue: events.oldValue, 40364 newValue: events.newValue, 40365 }; 40366 } 40367} 40368function formatMutationType(type) { 40369 switch (type) { 40370 case MutationType.direct: 40371 return 'mutation'; 40372 case MutationType.patchFunction: 40373 return '$patch'; 40374 case MutationType.patchObject: 40375 return '$patch'; 40376 default: 40377 return 'unknown'; 40378 } 40379} 40380 40381// timeline can be paused when directly changing the state 40382let isTimelineActive = true; 40383const componentStateTypes = []; 40384const MUTATIONS_LAYER_ID = 'pinia:mutations'; 40385const INSPECTOR_ID = 'pinia'; 40386const { assign: assign$1 } = Object; 40387/** 40388 * Gets the displayed name of a store in devtools 40389 * 40390 * @param id - id of the store 40391 * @returns a formatted string 40392 */ 40393const getStoreType = (id) => 'ð ' + id; 40394/** 40395 * Add the pinia plugin without any store. Allows displaying a Pinia plugin tab 40396 * as soon as it is added to the application. 40397 * 40398 * @param app - Vue application 40399 * @param pinia - pinia instance 40400 */ 40401function registerPiniaDevtools(app, pinia) { 40402 (0,_vue_devtools_api__WEBPACK_IMPORTED_MODULE_1__.setupDevtoolsPlugin)({ 40403 id: 'dev.esm.pinia', 40404 label: 'Pinia ð', 40405 logo: 'https://pinia.vuejs.org/logo.svg', 40406 packageName: 'pinia', 40407 homepage: 'https://pinia.vuejs.org', 40408 componentStateTypes, 40409 app, 40410 }, (api) => { 40411 if (typeof api.now !== 'function') { 40412 toastMessage('You seem to be using an outdated version of Vue Devtools. Are you still using the Beta release instead of the stable one? You can find the links at https://devtools.vuejs.org/guide/installation.html.'); 40413 } 40414 api.addTimelineLayer({ 40415 id: MUTATIONS_LAYER_ID, 40416 label: `Pinia ð`, 40417 color: 0xe5df88, 40418 }); 40419 api.addInspector({ 40420 id: INSPECTOR_ID, 40421 label: 'Pinia ð', 40422 icon: 'storage', 40423 treeFilterPlaceholder: 'Search stores', 40424 actions: [ 40425 { 40426 icon: 'content_copy', 40427 action: () => { 40428 actionGlobalCopyState(pinia); 40429 }, 40430 tooltip: 'Serialize and copy the state', 40431 }, 40432 { 40433 icon: 'content_paste', 40434 action: async () => { 40435 await actionGlobalPasteState(pinia); 40436 api.sendInspectorTree(INSPECTOR_ID); 40437 api.sendInspectorState(INSPECTOR_ID); 40438 }, 40439 tooltip: 'Replace the state with the content of your clipboard', 40440 }, 40441 { 40442 icon: 'save', 40443 action: () => { 40444 actionGlobalSaveState(pinia); 40445 }, 40446 tooltip: 'Save the state as a JSON file', 40447 }, 40448 { 40449 icon: 'folder_open', 40450 action: async () => { 40451 await actionGlobalOpenStateFile(pinia); 40452 api.sendInspectorTree(INSPECTOR_ID); 40453 api.sendInspectorState(INSPECTOR_ID); 40454 }, 40455 tooltip: 'Import the state from a JSON file', 40456 }, 40457 ], 40458 nodeActions: [ 40459 { 40460 icon: 'restore', 40461 tooltip: 'Reset the state (with "$reset")', 40462 action: (nodeId) => { 40463 const store = pinia._s.get(nodeId); 40464 if (!store) { 40465 toastMessage(`Cannot reset "${nodeId}" store because it wasn't found.`, 'warn'); 40466 } 40467 else if (typeof store.$reset !== 'function') { 40468 toastMessage(`Cannot reset "${nodeId}" store because it doesn't have a "$reset" method implemented.`, 'warn'); 40469 } 40470 else { 40471 store.$reset(); 40472 toastMessage(`Store "${nodeId}" reset.`); 40473 } 40474 }, 40475 }, 40476 ], 40477 }); 40478 api.on.inspectComponent((payload, ctx) => { 40479 const proxy = (payload.componentInstance && 40480 payload.componentInstance.proxy); 40481 if (proxy && proxy._pStores) { 40482 const piniaStores = payload.componentInstance.proxy._pStores; 40483 Object.values(piniaStores).forEach((store) => { 40484 payload.instanceData.state.push({ 40485 type: getStoreType(store.$id), 40486 key: 'state', 40487 editable: true, 40488 value: store._isOptionsAPI 40489 ? { 40490 _custom: { 40491 value: (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRaw)(store.$state), 40492 actions: [ 40493 { 40494 icon: 'restore', 40495 tooltip: 'Reset the state of this store', 40496 action: () => store.$reset(), 40497 }, 40498 ], 40499 }, 40500 } 40501 : // NOTE: workaround to unwrap transferred refs 40502 Object.keys(store.$state).reduce((state, key) => { 40503 state[key] = store.$state[key]; 40504 return state; 40505 }, {}), 40506 }); 40507 if (store._getters && store._getters.length) { 40508 payload.instanceData.state.push({ 40509 type: getStoreType(store.$id), 40510 key: 'getters', 40511 editable: false, 40512 value: store._getters.reduce((getters, key) => { 40513 try { 40514 getters[key] = store[key]; 40515 } 40516 catch (error) { 40517 // @ts-expect-error: we just want to show it in devtools 40518 getters[key] = error; 40519 } 40520 return getters; 40521 }, {}), 40522 }); 40523 } 40524 }); 40525 } 40526 }); 40527 api.on.getInspectorTree((payload) => { 40528 if (payload.app === app && payload.inspectorId === INSPECTOR_ID) { 40529 let stores = [pinia]; 40530 stores = stores.concat(Array.from(pinia._s.values())); 40531 payload.rootNodes = (payload.filter 40532 ? stores.filter((store) => '$id' in store 40533 ? store.$id 40534 .toLowerCase() 40535 .includes(payload.filter.toLowerCase()) 40536 : PINIA_ROOT_LABEL.toLowerCase().includes(payload.filter.toLowerCase())) 40537 : stores).map(formatStoreForInspectorTree); 40538 } 40539 }); 40540 // Expose pinia instance as $pinia to window 40541 globalThis.$pinia = pinia; 40542 api.on.getInspectorState((payload) => { 40543 if (payload.app === app && payload.inspectorId === INSPECTOR_ID) { 40544 const inspectedStore = payload.nodeId === PINIA_ROOT_ID 40545 ? pinia 40546 : pinia._s.get(payload.nodeId); 40547 if (!inspectedStore) { 40548 // this could be the selected store restored for a different project 40549 // so it's better not to say anything here 40550 return; 40551 } 40552 if (inspectedStore) { 40553 // Expose selected store as $store to window 40554 if (payload.nodeId !== PINIA_ROOT_ID) 40555 globalThis.$store = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRaw)(inspectedStore); 40556 payload.state = formatStoreForInspectorState(inspectedStore); 40557 } 40558 } 40559 }); 40560 api.on.editInspectorState((payload, ctx) => { 40561 if (payload.app === app && payload.inspectorId === INSPECTOR_ID) { 40562 const inspectedStore = payload.nodeId === PINIA_ROOT_ID 40563 ? pinia 40564 : pinia._s.get(payload.nodeId); 40565 if (!inspectedStore) { 40566 return toastMessage(`store "${payload.nodeId}" not found`, 'error'); 40567 } 40568 const { path } = payload; 40569 if (!isPinia(inspectedStore)) { 40570 // access only the state 40571 if (path.length !== 1 || 40572 !inspectedStore._customProperties.has(path[0]) || 40573 path[0] in inspectedStore.$state) { 40574 path.unshift('$state'); 40575 } 40576 } 40577 else { 40578 // Root access, we can omit the `.value` because the devtools API does it for us 40579 path.unshift('state'); 40580 } 40581 isTimelineActive = false; 40582 payload.set(inspectedStore, path, payload.state.value); 40583 isTimelineActive = true; 40584 } 40585 }); 40586 api.on.editComponentState((payload) => { 40587 if (payload.type.startsWith('ð')) { 40588 const storeId = payload.type.replace(/^ð\s*/, ''); 40589 const store = pinia._s.get(storeId); 40590 if (!store) { 40591 return toastMessage(`store "${storeId}" not found`, 'error'); 40592 } 40593 const { path } = payload; 40594 if (path[0] !== 'state') { 40595 return toastMessage(`Invalid path for store "${storeId}":\n${path}\nOnly state can be modified.`); 40596 } 40597 // rewrite the first entry to be able to directly set the state as 40598 // well as any other path 40599 path[0] = '$state'; 40600 isTimelineActive = false; 40601 payload.set(store, path, payload.state.value); 40602 isTimelineActive = true; 40603 } 40604 }); 40605 }); 40606} 40607function addStoreToDevtools(app, store) { 40608 if (!componentStateTypes.includes(getStoreType(store.$id))) { 40609 componentStateTypes.push(getStoreType(store.$id)); 40610 } 40611 (0,_vue_devtools_api__WEBPACK_IMPORTED_MODULE_1__.setupDevtoolsPlugin)({ 40612 id: 'dev.esm.pinia', 40613 label: 'Pinia ð', 40614 logo: 'https://pinia.vuejs.org/logo.svg', 40615 packageName: 'pinia', 40616 homepage: 'https://pinia.vuejs.org', 40617 componentStateTypes, 40618 app, 40619 settings: { 40620 logStoreChanges: { 40621 label: 'Notify about new/deleted stores', 40622 type: 'boolean', 40623 defaultValue: true, 40624 }, 40625 // useEmojis: { 40626 // label: 'Use emojis in messages â¡ï¸', 40627 // type: 'boolean', 40628 // defaultValue: true, 40629 // }, 40630 }, 40631 }, (api) => { 40632 // gracefully handle errors 40633 const now = typeof api.now === 'function' ? api.now.bind(api) : Date.now; 40634 store.$onAction(({ after, onError, name, args }) => { 40635 const groupId = runningActionId++; 40636 api.addTimelineEvent({ 40637 layerId: MUTATIONS_LAYER_ID, 40638 event: { 40639 time: now(), 40640 title: 'ð« ' + name, 40641 subtitle: 'start', 40642 data: { 40643 store: formatDisplay(store.$id), 40644 action: formatDisplay(name), 40645 args, 40646 }, 40647 groupId, 40648 }, 40649 }); 40650 after((result) => { 40651 activeAction = undefined; 40652 api.addTimelineEvent({ 40653 layerId: MUTATIONS_LAYER_ID, 40654 event: { 40655 time: now(), 40656 title: 'ð¬ ' + name, 40657 subtitle: 'end', 40658 data: { 40659 store: formatDisplay(store.$id), 40660 action: formatDisplay(name), 40661 args, 40662 result, 40663 }, 40664 groupId, 40665 }, 40666 }); 40667 }); 40668 onError((error) => { 40669 activeAction = undefined; 40670 api.addTimelineEvent({ 40671 layerId: MUTATIONS_LAYER_ID, 40672 event: { 40673 time: now(), 40674 logType: 'error', 40675 title: 'ð¥ ' + name, 40676 subtitle: 'end', 40677 data: { 40678 store: formatDisplay(store.$id), 40679 action: formatDisplay(name), 40680 args, 40681 error, 40682 }, 40683 groupId, 40684 }, 40685 }); 40686 }); 40687 }, true); 40688 store._customProperties.forEach((name) => { 40689 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.watch)(() => (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(store[name]), (newValue, oldValue) => { 40690 api.notifyComponentUpdate(); 40691 api.sendInspectorState(INSPECTOR_ID); 40692 if (isTimelineActive) { 40693 api.addTimelineEvent({ 40694 layerId: MUTATIONS_LAYER_ID, 40695 event: { 40696 time: now(), 40697 title: 'Change', 40698 subtitle: name, 40699 data: { 40700 newValue, 40701 oldValue, 40702 }, 40703 groupId: activeAction, 40704 }, 40705 }); 40706 } 40707 }, { deep: true }); 40708 }); 40709 store.$subscribe(({ events, type }, state) => { 40710 api.notifyComponentUpdate(); 40711 api.sendInspectorState(INSPECTOR_ID); 40712 if (!isTimelineActive) 40713 return; 40714 // rootStore.state[store.id] = state 40715 const eventData = { 40716 time: now(), 40717 title: formatMutationType(type), 40718 data: assign$1({ store: formatDisplay(store.$id) }, formatEventData(events)), 40719 groupId: activeAction, 40720 }; 40721 if (type === MutationType.patchFunction) { 40722 eventData.subtitle = '⤵ï¸'; 40723 } 40724 else if (type === MutationType.patchObject) { 40725 eventData.subtitle = 'ð§©'; 40726 } 40727 else if (events && !Array.isArray(events)) { 40728 eventData.subtitle = events.type; 40729 } 40730 if (events) { 40731 eventData.data['rawEvent(s)'] = { 40732 _custom: { 40733 display: 'DebuggerEvent', 40734 type: 'object', 40735 tooltip: 'raw DebuggerEvent[]', 40736 value: events, 40737 }, 40738 }; 40739 } 40740 api.addTimelineEvent({ 40741 layerId: MUTATIONS_LAYER_ID, 40742 event: eventData, 40743 }); 40744 }, { detached: true, flush: 'sync' }); 40745 const hotUpdate = store._hotUpdate; 40746 store._hotUpdate = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.markRaw)((newStore) => { 40747 hotUpdate(newStore); 40748 api.addTimelineEvent({ 40749 layerId: MUTATIONS_LAYER_ID, 40750 event: { 40751 time: now(), 40752 title: 'ð¥ ' + store.$id, 40753 subtitle: 'HMR update', 40754 data: { 40755 store: formatDisplay(store.$id), 40756 info: formatDisplay(`HMR update`), 40757 }, 40758 }, 40759 }); 40760 // update the devtools too 40761 api.notifyComponentUpdate(); 40762 api.sendInspectorTree(INSPECTOR_ID); 40763 api.sendInspectorState(INSPECTOR_ID); 40764 }); 40765 const { $dispose } = store; 40766 store.$dispose = () => { 40767 $dispose(); 40768 api.notifyComponentUpdate(); 40769 api.sendInspectorTree(INSPECTOR_ID); 40770 api.sendInspectorState(INSPECTOR_ID); 40771 api.getSettings().logStoreChanges && 40772 toastMessage(`Disposed "${store.$id}" store ð`); 40773 }; 40774 // trigger an update so it can display new registered stores 40775 api.notifyComponentUpdate(); 40776 api.sendInspectorTree(INSPECTOR_ID); 40777 api.sendInspectorState(INSPECTOR_ID); 40778 api.getSettings().logStoreChanges && 40779 toastMessage(`"${store.$id}" store installed ð`); 40780 }); 40781} 40782let runningActionId = 0; 40783let activeAction; 40784/** 40785 * Patches a store to enable action grouping in devtools by wrapping the store with a Proxy that is passed as the 40786 * context of all actions, allowing us to set `runningAction` on each access and effectively associating any state 40787 * mutation to the action. 40788 * 40789 * @param store - store to patch 40790 * @param actionNames - list of actionst to patch 40791 */ 40792function patchActionForGrouping(store, actionNames, wrapWithProxy) { 40793 // original actions of the store as they are given by pinia. We are going to override them 40794 const actions = actionNames.reduce((storeActions, actionName) => { 40795 // use toRaw to avoid tracking #541 40796 storeActions[actionName] = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRaw)(store)[actionName]; 40797 return storeActions; 40798 }, {}); 40799 for (const actionName in actions) { 40800 store[actionName] = function () { 40801 // the running action id is incremented in a before action hook 40802 const _actionId = runningActionId; 40803 const trackedStore = wrapWithProxy 40804 ? new Proxy(store, { 40805 get(...args) { 40806 activeAction = _actionId; 40807 return Reflect.get(...args); 40808 }, 40809 set(...args) { 40810 activeAction = _actionId; 40811 return Reflect.set(...args); 40812 }, 40813 }) 40814 : store; 40815 // For Setup Stores we need https://github.com/tc39/proposal-async-context 40816 activeAction = _actionId; 40817 const retValue = actions[actionName].apply(trackedStore, arguments); 40818 // this is safer as async actions in Setup Stores would associate mutations done outside of the action 40819 activeAction = undefined; 40820 return retValue; 40821 }; 40822 } 40823} 40824/** 40825 * pinia.use(devtoolsPlugin) 40826 */ 40827function devtoolsPlugin({ app, store, options }) { 40828 // HMR module 40829 if (store.$id.startsWith('__hot:')) { 40830 return; 40831 } 40832 // detect option api vs setup api 40833 store._isOptionsAPI = !!options.state; 40834 // Do not overwrite actions mocked by @pinia/testing (#2298) 40835 if (!store._p._testing) { 40836 patchActionForGrouping(store, Object.keys(options.actions), store._isOptionsAPI); 40837 // Upgrade the HMR to also update the new actions 40838 const originalHotUpdate = store._hotUpdate; 40839 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRaw)(store)._hotUpdate = function (newStore) { 40840 originalHotUpdate.apply(this, arguments); 40841 patchActionForGrouping(store, Object.keys(newStore._hmrPayload.actions), !!store._isOptionsAPI); 40842 }; 40843 } 40844 addStoreToDevtools(app, 40845 // FIXME: is there a way to allow the assignment from Store<Id, S, G, A> to StoreGeneric? 40846 store); 40847} 40848 40849/** 40850 * Creates a Pinia instance to be used by the application 40851 */ 40852function createPinia() { 40853 const scope = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.effectScope)(true); 40854 // NOTE: here we could check the window object for a state and directly set it 40855 // if there is anything like it with Vue 3 SSR 40856 const state = scope.run(() => (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)({})); 40857 let _p = []; 40858 // plugins added before calling app.use(pinia) 40859 let toBeInstalled = []; 40860 const pinia = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.markRaw)({ 40861 install(app) { 40862 // this allows calling useStore() outside of a component setup after 40863 // installing pinia's plugin 40864 setActivePinia(pinia); 40865 if (!vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 40866 pinia._a = app; 40867 app.provide(piniaSymbol, pinia); 40868 app.config.globalProperties.$pinia = pinia; 40869 /* istanbul ignore else */ 40870 if (( true) && IS_CLIENT) { 40871 registerPiniaDevtools(app, pinia); 40872 } 40873 toBeInstalled.forEach((plugin) => _p.push(plugin)); 40874 toBeInstalled = []; 40875 } 40876 }, 40877 use(plugin) { 40878 if (!this._a && !vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 40879 toBeInstalled.push(plugin); 40880 } 40881 else { 40882 _p.push(plugin); 40883 } 40884 return this; 40885 }, 40886 _p, 40887 // it's actually undefined here 40888 // @ts-expect-error 40889 _a: null, 40890 _e: scope, 40891 _s: new Map(), 40892 state, 40893 }); 40894 // pinia devtools rely on dev only features so they cannot be forced unless 40895 // the dev build of Vue is used. Avoid old browsers like IE11. 40896 if (( true) && IS_CLIENT && typeof Proxy !== 'undefined') { 40897 pinia.use(devtoolsPlugin); 40898 } 40899 return pinia; 40900} 40901/** 40902 * Dispose a Pinia instance by stopping its effectScope and removing the state, plugins and stores. This is mostly 40903 * useful in tests, with both a testing pinia or a regular pinia and in applications that use multiple pinia instances. 40904 * Once disposed, the pinia instance cannot be used anymore. 40905 * 40906 * @param pinia - pinia instance 40907 */ 40908function disposePinia(pinia) { 40909 pinia._e.stop(); 40910 pinia._s.clear(); 40911 pinia._p.splice(0); 40912 pinia.state.value = {}; 40913 // @ts-expect-error: non valid 40914 pinia._a = null; 40915} 40916 40917/** 40918 * Checks if a function is a `StoreDefinition`. 40919 * 40920 * @param fn - object to test 40921 * @returns true if `fn` is a StoreDefinition 40922 */ 40923const isUseStore = (fn) => { 40924 return typeof fn === 'function' && typeof fn.$id === 'string'; 40925}; 40926/** 40927 * Mutates in place `newState` with `oldState` to _hot update_ it. It will 40928 * remove any key not existing in `newState` and recursively merge plain 40929 * objects. 40930 * 40931 * @param newState - new state object to be patched 40932 * @param oldState - old state that should be used to patch newState 40933 * @returns - newState 40934 */ 40935function patchObject(newState, oldState) { 40936 // no need to go through symbols because they cannot be serialized anyway 40937 for (const key in oldState) { 40938 const subPatch = oldState[key]; 40939 // skip the whole sub tree 40940 if (!(key in newState)) { 40941 continue; 40942 } 40943 const targetValue = newState[key]; 40944 if (isPlainObject(targetValue) && 40945 isPlainObject(subPatch) && 40946 !(0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isRef)(subPatch) && 40947 !(0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isReactive)(subPatch)) { 40948 newState[key] = patchObject(targetValue, subPatch); 40949 } 40950 else { 40951 // objects are either a bit more complex (e.g. refs) or primitives, so we 40952 // just set the whole thing 40953 if (vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 40954 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.set)(newState, key, subPatch); 40955 } 40956 else { 40957 newState[key] = subPatch; 40958 } 40959 } 40960 } 40961 return newState; 40962} 40963/** 40964 * Creates an _accept_ function to pass to `import.meta.hot` in Vite applications. 40965 * 40966 * @example 40967 * ```js 40968 * const useUser = defineStore(...) 40969 * if (import.meta.hot) { 40970 * import.meta.hot.accept(acceptHMRUpdate(useUser, import.meta.hot)) 40971 * } 40972 * ``` 40973 * 40974 * @param initialUseStore - return of the defineStore to hot update 40975 * @param hot - `import.meta.hot` 40976 */ 40977function acceptHMRUpdate(initialUseStore, hot) { 40978 // strip as much as possible from iife.prod 40979 if (false) {} 40980 return (newModule) => { 40981 const pinia = hot.data.pinia || initialUseStore._pinia; 40982 if (!pinia) { 40983 // this store is still not used 40984 return; 40985 } 40986 // preserve the pinia instance across loads 40987 hot.data.pinia = pinia; 40988 // console.log('got data', newStore) 40989 for (const exportName in newModule) { 40990 const useStore = newModule[exportName]; 40991 // console.log('checking for', exportName) 40992 if (isUseStore(useStore) && pinia._s.has(useStore.$id)) { 40993 // console.log('Accepting update for', useStore.$id) 40994 const id = useStore.$id; 40995 if (id !== initialUseStore.$id) { 40996 console.warn(`The id of the store changed from "${initialUseStore.$id}" to "${id}". Reloading.`); 40997 // return import.meta.hot.invalidate() 40998 return hot.invalidate(); 40999 } 41000 const existingStore = pinia._s.get(id); 41001 if (!existingStore) { 41002 console.log(`[Pinia]: skipping hmr because store doesn't exist yet`); 41003 return; 41004 } 41005 useStore(pinia, existingStore); 41006 } 41007 } 41008 }; 41009} 41010 41011const noop = () => { }; 41012function addSubscription(subscriptions, callback, detached, onCleanup = noop) { 41013 subscriptions.push(callback); 41014 const removeSubscription = () => { 41015 const idx = subscriptions.indexOf(callback); 41016 if (idx > -1) { 41017 subscriptions.splice(idx, 1); 41018 onCleanup(); 41019 } 41020 }; 41021 if (!detached && (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope)()) { 41022 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose)(removeSubscription); 41023 } 41024 return removeSubscription; 41025} 41026function triggerSubscriptions(subscriptions, ...args) { 41027 subscriptions.slice().forEach((callback) => { 41028 callback(...args); 41029 }); 41030} 41031 41032const fallbackRunWithContext = (fn) => fn(); 41033/** 41034 * Marks a function as an action for `$onAction` 41035 * @internal 41036 */ 41037const ACTION_MARKER = Symbol(); 41038/** 41039 * Action name symbol. Allows to add a name to an action after defining it 41040 * @internal 41041 */ 41042const ACTION_NAME = Symbol(); 41043function mergeReactiveObjects(target, patchToApply) { 41044 // Handle Map instances 41045 if (target instanceof Map && patchToApply instanceof Map) { 41046 patchToApply.forEach((value, key) => target.set(key, value)); 41047 } 41048 else if (target instanceof Set && patchToApply instanceof Set) { 41049 // Handle Set instances 41050 patchToApply.forEach(target.add, target); 41051 } 41052 // no need to go through symbols because they cannot be serialized anyway 41053 for (const key in patchToApply) { 41054 if (!patchToApply.hasOwnProperty(key)) 41055 continue; 41056 const subPatch = patchToApply[key]; 41057 const targetValue = target[key]; 41058 if (isPlainObject(targetValue) && 41059 isPlainObject(subPatch) && 41060 target.hasOwnProperty(key) && 41061 !(0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isRef)(subPatch) && 41062 !(0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isReactive)(subPatch)) { 41063 // NOTE: here I wanted to warn about inconsistent types but it's not possible because in setup stores one might 41064 // start the value of a property as a certain type e.g. a Map, and then for some reason, during SSR, change that 41065 // to `undefined`. When trying to hydrate, we want to override the Map with `undefined`. 41066 target[key] = mergeReactiveObjects(targetValue, subPatch); 41067 } 41068 else { 41069 // @ts-expect-error: subPatch is a valid value 41070 target[key] = subPatch; 41071 } 41072 } 41073 return target; 41074} 41075const skipHydrateSymbol = ( true) 41076 ? Symbol('pinia:skipHydration') 41077 : /* istanbul ignore next */ 0; 41078/** 41079 * Tells Pinia to skip the hydration process of a given object. This is useful in setup stores (only) when you return a 41080 * stateful object in the store but it isn't really state. e.g. returning a router instance in a setup store. 41081 * 41082 * @param obj - target object 41083 * @returns obj 41084 */ 41085function skipHydrate(obj) { 41086 return Object.defineProperty(obj, skipHydrateSymbol, {}); 41087} 41088/** 41089 * Returns whether a value should be hydrated 41090 * 41091 * @param obj - target variable 41092 * @returns true if `obj` should be hydrated 41093 */ 41094function shouldHydrate(obj) { 41095 return !isPlainObject(obj) || !obj.hasOwnProperty(skipHydrateSymbol); 41096} 41097const { assign } = Object; 41098function isComputed(o) { 41099 return !!((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isRef)(o) && o.effect); 41100} 41101function createOptionsStore(id, options, pinia, hot) { 41102 const { state, actions, getters } = options; 41103 const initialState = pinia.state.value[id]; 41104 let store; 41105 function setup() { 41106 if (!initialState && ( false || !hot)) { 41107 /* istanbul ignore if */ 41108 if (vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 41109 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.set)(pinia.state.value, id, state ? state() : {}); 41110 } 41111 else { 41112 pinia.state.value[id] = state ? state() : {}; 41113 } 41114 } 41115 // avoid creating a state in pinia.state.value 41116 const localState = ( true) && hot 41117 ? // use ref() to unwrap refs inside state TODO: check if this is still necessary 41118 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRefs)((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)(state ? state() : {}).value) 41119 : (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRefs)(pinia.state.value[id]); 41120 return assign(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name) => { 41121 if (( true) && name in localState) { 41122 console.warn(`[ð]: A getter cannot have the same name as another state property. Rename one of them. Found with "${name}" in store "${id}".`); 41123 } 41124 computedGetters[name] = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.markRaw)((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 41125 setActivePinia(pinia); 41126 // it was created just before 41127 const store = pinia._s.get(id); 41128 // allow cross using stores 41129 /* istanbul ignore if */ 41130 if (vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2 && !store._r) 41131 return; 41132 // @ts-expect-error 41133 // return getters![name].call(context, context) 41134 // TODO: avoid reading the getter while assigning with a global variable 41135 return getters[name].call(store, store); 41136 })); 41137 return computedGetters; 41138 }, {})); 41139 } 41140 store = createSetupStore(id, setup, options, pinia, hot, true); 41141 return store; 41142} 41143function createSetupStore($id, setup, options = {}, pinia, hot, isOptionsStore) { 41144 let scope; 41145 const optionsForPlugin = assign({ actions: {} }, options); 41146 /* istanbul ignore if */ 41147 if (( true) && !pinia._e.active) { 41148 throw new Error('Pinia destroyed'); 41149 } 41150 // watcher options for $subscribe 41151 const $subscribeOptions = { deep: true }; 41152 /* istanbul ignore else */ 41153 if (( true) && !vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 41154 $subscribeOptions.onTrigger = (event) => { 41155 /* istanbul ignore else */ 41156 if (isListening) { 41157 debuggerEvents = event; 41158 // avoid triggering this while the store is being built and the state is being set in pinia 41159 } 41160 else if (isListening == false && !store._hotUpdating) { 41161 // let patch send all the events together later 41162 /* istanbul ignore else */ 41163 if (Array.isArray(debuggerEvents)) { 41164 debuggerEvents.push(event); 41165 } 41166 else { 41167 console.error('ð debuggerEvents should be an array. This is most likely an internal Pinia bug.'); 41168 } 41169 } 41170 }; 41171 } 41172 // internal state 41173 let isListening; // set to true at the end 41174 let isSyncListening; // set to true at the end 41175 let subscriptions = []; 41176 let actionSubscriptions = []; 41177 let debuggerEvents; 41178 const initialState = pinia.state.value[$id]; 41179 // avoid setting the state for option stores if it is set 41180 // by the setup 41181 if (!isOptionsStore && !initialState && ( false || !hot)) { 41182 /* istanbul ignore if */ 41183 if (vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 41184 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.set)(pinia.state.value, $id, {}); 41185 } 41186 else { 41187 pinia.state.value[$id] = {}; 41188 } 41189 } 41190 const hotState = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)({}); 41191 // avoid triggering too many listeners 41192 // https://github.com/vuejs/pinia/issues/1129 41193 let activeListener; 41194 function $patch(partialStateOrMutator) { 41195 let subscriptionMutation; 41196 isListening = isSyncListening = false; 41197 // reset the debugger events since patches are sync 41198 /* istanbul ignore else */ 41199 if ((true)) { 41200 debuggerEvents = []; 41201 } 41202 if (typeof partialStateOrMutator === 'function') { 41203 partialStateOrMutator(pinia.state.value[$id]); 41204 subscriptionMutation = { 41205 type: MutationType.patchFunction, 41206 storeId: $id, 41207 events: debuggerEvents, 41208 }; 41209 } 41210 else { 41211 mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator); 41212 subscriptionMutation = { 41213 type: MutationType.patchObject, 41214 payload: partialStateOrMutator, 41215 storeId: $id, 41216 events: debuggerEvents, 41217 }; 41218 } 41219 const myListenerId = (activeListener = Symbol()); 41220 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.nextTick)().then(() => { 41221 if (activeListener === myListenerId) { 41222 isListening = true; 41223 } 41224 }); 41225 isSyncListening = true; 41226 // because we paused the watcher, we need to manually call the subscriptions 41227 triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]); 41228 } 41229 const $reset = isOptionsStore 41230 ? function $reset() { 41231 const { state } = options; 41232 const newState = state ? state() : {}; 41233 // we use a patch to group all changes into one single subscription 41234 this.$patch(($state) => { 41235 // @ts-expect-error: FIXME: shouldn't error? 41236 assign($state, newState); 41237 }); 41238 } 41239 : /* istanbul ignore next */ 41240 ( true) 41241 ? () => { 41242 throw new Error(`ð: Store "${$id}" is built using the setup syntax and does not implement $reset().`); 41243 } 41244 : 0; 41245 function $dispose() { 41246 scope.stop(); 41247 subscriptions = []; 41248 actionSubscriptions = []; 41249 pinia._s.delete($id); 41250 } 41251 /** 41252 * Helper that wraps function so it can be tracked with $onAction 41253 * @param fn - action to wrap 41254 * @param name - name of the action 41255 */ 41256 const action = (fn, name = '') => { 41257 if (ACTION_MARKER in fn) { 41258 fn[ACTION_NAME] = name; 41259 return fn; 41260 } 41261 const wrappedAction = function () { 41262 setActivePinia(pinia); 41263 const args = Array.from(arguments); 41264 const afterCallbackList = []; 41265 const onErrorCallbackList = []; 41266 function after(callback) { 41267 afterCallbackList.push(callback); 41268 } 41269 function onError(callback) { 41270 onErrorCallbackList.push(callback); 41271 } 41272 // @ts-expect-error 41273 triggerSubscriptions(actionSubscriptions, { 41274 args, 41275 name: wrappedAction[ACTION_NAME], 41276 store, 41277 after, 41278 onError, 41279 }); 41280 let ret; 41281 try { 41282 ret = fn.apply(this && this.$id === $id ? this : store, args); 41283 // handle sync errors 41284 } 41285 catch (error) { 41286 triggerSubscriptions(onErrorCallbackList, error); 41287 throw error; 41288 } 41289 if (ret instanceof Promise) { 41290 return ret 41291 .then((value) => { 41292 triggerSubscriptions(afterCallbackList, value); 41293 return value; 41294 }) 41295 .catch((error) => { 41296 triggerSubscriptions(onErrorCallbackList, error); 41297 return Promise.reject(error); 41298 }); 41299 } 41300 // trigger after callbacks 41301 triggerSubscriptions(afterCallbackList, ret); 41302 return ret; 41303 }; 41304 wrappedAction[ACTION_MARKER] = true; 41305 wrappedAction[ACTION_NAME] = name; // will be set later 41306 // @ts-expect-error: we are intentionally limiting the returned type to just Fn 41307 // because all the added properties are internals that are exposed through `$onAction()` only 41308 return wrappedAction; 41309 }; 41310 const _hmrPayload = /*#__PURE__*/ (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.markRaw)({ 41311 actions: {}, 41312 getters: {}, 41313 state: [], 41314 hotState, 41315 }); 41316 const partialStore = { 41317 _p: pinia, 41318 // _s: scope, 41319 $id, 41320 $onAction: addSubscription.bind(null, actionSubscriptions), 41321 $patch, 41322 $reset, 41323 $subscribe(callback, options = {}) { 41324 const removeSubscription = addSubscription(subscriptions, callback, options.detached, () => stopWatcher()); 41325 const stopWatcher = scope.run(() => (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.watch)(() => pinia.state.value[$id], (state) => { 41326 if (options.flush === 'sync' ? isSyncListening : isListening) { 41327 callback({ 41328 storeId: $id, 41329 type: MutationType.direct, 41330 events: debuggerEvents, 41331 }, state); 41332 } 41333 }, assign({}, $subscribeOptions, options))); 41334 return removeSubscription; 41335 }, 41336 $dispose, 41337 }; 41338 /* istanbul ignore if */ 41339 if (vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 41340 // start as non ready 41341 partialStore._r = false; 41342 } 41343 const store = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.reactive)( true 41344 ? assign({ 41345 _hmrPayload, 41346 _customProperties: (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.markRaw)(new Set()), // devtools custom properties 41347 }, partialStore 41348 // must be added later 41349 // setupStore 41350 ) 41351 : 0); 41352 // store the partial store now so the setup of stores can instantiate each other before they are finished without 41353 // creating infinite loops. 41354 pinia._s.set($id, store); 41355 const runWithContext = (pinia._a && pinia._a.runWithContext) || fallbackRunWithContext; 41356 // TODO: idea create skipSerialize that marks properties as non serializable and they are skipped 41357 const setupStore = runWithContext(() => pinia._e.run(() => (scope = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.effectScope)()).run(() => setup({ action })))); 41358 // overwrite existing actions to support $onAction 41359 for (const key in setupStore) { 41360 const prop = setupStore[key]; 41361 if (((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isRef)(prop) && !isComputed(prop)) || (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isReactive)(prop)) { 41362 // mark it as a piece of state to be serialized 41363 if (( true) && hot) { 41364 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.set)(hotState.value, key, (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRef)(setupStore, key)); 41365 // createOptionStore directly sets the state in pinia.state.value so we 41366 // can just skip that 41367 } 41368 else if (!isOptionsStore) { 41369 // in setup stores we must hydrate the state and sync pinia state tree with the refs the user just created 41370 if (initialState && shouldHydrate(prop)) { 41371 if ((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isRef)(prop)) { 41372 prop.value = initialState[key]; 41373 } 41374 else { 41375 // probably a reactive object, lets recursively assign 41376 // @ts-expect-error: prop is unknown 41377 mergeReactiveObjects(prop, initialState[key]); 41378 } 41379 } 41380 // transfer the ref to the pinia state to keep everything in sync 41381 /* istanbul ignore if */ 41382 if (vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 41383 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.set)(pinia.state.value[$id], key, prop); 41384 } 41385 else { 41386 pinia.state.value[$id][key] = prop; 41387 } 41388 } 41389 /* istanbul ignore else */ 41390 if ((true)) { 41391 _hmrPayload.state.push(key); 41392 } 41393 // action 41394 } 41395 else if (typeof prop === 'function') { 41396 const actionValue = ( true) && hot ? prop : action(prop, key); 41397 // this a hot module replacement store because the hotUpdate method needs 41398 // to do it with the right context 41399 /* istanbul ignore if */ 41400 if (vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 41401 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.set)(setupStore, key, actionValue); 41402 } 41403 else { 41404 // @ts-expect-error 41405 setupStore[key] = actionValue; 41406 } 41407 /* istanbul ignore else */ 41408 if ((true)) { 41409 _hmrPayload.actions[key] = prop; 41410 } 41411 // list actions so they can be used in plugins 41412 // @ts-expect-error 41413 optionsForPlugin.actions[key] = prop; 41414 } 41415 else if ((true)) { 41416 // add getters for devtools 41417 if (isComputed(prop)) { 41418 _hmrPayload.getters[key] = isOptionsStore 41419 ? // @ts-expect-error 41420 options.getters[key] 41421 : prop; 41422 if (IS_CLIENT) { 41423 const getters = setupStore._getters || 41424 // @ts-expect-error: same 41425 (setupStore._getters = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.markRaw)([])); 41426 getters.push(key); 41427 } 41428 } 41429 } 41430 } 41431 // add the state, getters, and action properties 41432 /* istanbul ignore if */ 41433 if (vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 41434 Object.keys(setupStore).forEach((key) => { 41435 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.set)(store, key, setupStore[key]); 41436 }); 41437 } 41438 else { 41439 assign(store, setupStore); 41440 // allows retrieving reactive objects with `storeToRefs()`. Must be called after assigning to the reactive object. 41441 // Make `storeToRefs()` work with `reactive()` #799 41442 assign((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRaw)(store), setupStore); 41443 } 41444 // use this instead of a computed with setter to be able to create it anywhere 41445 // without linking the computed lifespan to wherever the store is first 41446 // created. 41447 Object.defineProperty(store, '$state', { 41448 get: () => (( true) && hot ? hotState.value : pinia.state.value[$id]), 41449 set: (state) => { 41450 /* istanbul ignore if */ 41451 if (( true) && hot) { 41452 throw new Error('cannot set hotState'); 41453 } 41454 $patch(($state) => { 41455 // @ts-expect-error: FIXME: shouldn't error? 41456 assign($state, state); 41457 }); 41458 }, 41459 }); 41460 // add the hotUpdate before plugins to allow them to override it 41461 /* istanbul ignore else */ 41462 if ((true)) { 41463 store._hotUpdate = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.markRaw)((newStore) => { 41464 store._hotUpdating = true; 41465 newStore._hmrPayload.state.forEach((stateKey) => { 41466 if (stateKey in store.$state) { 41467 const newStateTarget = newStore.$state[stateKey]; 41468 const oldStateSource = store.$state[stateKey]; 41469 if (typeof newStateTarget === 'object' && 41470 isPlainObject(newStateTarget) && 41471 isPlainObject(oldStateSource)) { 41472 patchObject(newStateTarget, oldStateSource); 41473 } 41474 else { 41475 // transfer the ref 41476 newStore.$state[stateKey] = oldStateSource; 41477 } 41478 } 41479 // patch direct access properties to allow store.stateProperty to work as 41480 // store.$state.stateProperty 41481 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.set)(store, stateKey, (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRef)(newStore.$state, stateKey)); 41482 }); 41483 // remove deleted state properties 41484 Object.keys(store.$state).forEach((stateKey) => { 41485 if (!(stateKey in newStore.$state)) { 41486 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.del)(store, stateKey); 41487 } 41488 }); 41489 // avoid devtools logging this as a mutation 41490 isListening = false; 41491 isSyncListening = false; 41492 pinia.state.value[$id] = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRef)(newStore._hmrPayload, 'hotState'); 41493 isSyncListening = true; 41494 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.nextTick)().then(() => { 41495 isListening = true; 41496 }); 41497 for (const actionName in newStore._hmrPayload.actions) { 41498 const actionFn = newStore[actionName]; 41499 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.set)(store, actionName, action(actionFn, actionName)); 41500 } 41501 // TODO: does this work in both setup and option store? 41502 for (const getterName in newStore._hmrPayload.getters) { 41503 const getter = newStore._hmrPayload.getters[getterName]; 41504 const getterValue = isOptionsStore 41505 ? // special handling of options api 41506 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 41507 setActivePinia(pinia); 41508 return getter.call(store, store); 41509 }) 41510 : getter; 41511 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.set)(store, getterName, getterValue); 41512 } 41513 // remove deleted getters 41514 Object.keys(store._hmrPayload.getters).forEach((key) => { 41515 if (!(key in newStore._hmrPayload.getters)) { 41516 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.del)(store, key); 41517 } 41518 }); 41519 // remove old actions 41520 Object.keys(store._hmrPayload.actions).forEach((key) => { 41521 if (!(key in newStore._hmrPayload.actions)) { 41522 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.del)(store, key); 41523 } 41524 }); 41525 // update the values used in devtools and to allow deleting new properties later on 41526 store._hmrPayload = newStore._hmrPayload; 41527 store._getters = newStore._getters; 41528 store._hotUpdating = false; 41529 }); 41530 } 41531 if (( true) && IS_CLIENT) { 41532 const nonEnumerable = { 41533 writable: true, 41534 configurable: true, 41535 // avoid warning on devtools trying to display this property 41536 enumerable: false, 41537 }; 41538 ['_p', '_hmrPayload', '_getters', '_customProperties'].forEach((p) => { 41539 Object.defineProperty(store, p, assign({ value: store[p] }, nonEnumerable)); 41540 }); 41541 } 41542 /* istanbul ignore if */ 41543 if (vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 41544 // mark the store as ready before plugins 41545 store._r = true; 41546 } 41547 // apply all plugins 41548 pinia._p.forEach((extender) => { 41549 /* istanbul ignore else */ 41550 if (( true) && IS_CLIENT) { 41551 const extensions = scope.run(() => extender({ 41552 store: store, 41553 app: pinia._a, 41554 pinia, 41555 options: optionsForPlugin, 41556 })); 41557 Object.keys(extensions || {}).forEach((key) => store._customProperties.add(key)); 41558 assign(store, extensions); 41559 } 41560 else { 41561 assign(store, scope.run(() => extender({ 41562 store: store, 41563 app: pinia._a, 41564 pinia, 41565 options: optionsForPlugin, 41566 }))); 41567 } 41568 }); 41569 if (( true) && 41570 store.$state && 41571 typeof store.$state === 'object' && 41572 typeof store.$state.constructor === 'function' && 41573 !store.$state.constructor.toString().includes('[native code]')) { 41574 console.warn(`[ð]: The "state" must be a plain object. It cannot be\n` + 41575 `\tstate: () => new MyClass()\n` + 41576 `Found in store "${store.$id}".`); 41577 } 41578 // only apply hydrate to option stores with an initial state in pinia 41579 if (initialState && 41580 isOptionsStore && 41581 options.hydrate) { 41582 options.hydrate(store.$state, initialState); 41583 } 41584 isListening = true; 41585 isSyncListening = true; 41586 return store; 41587} 41588// allows unused stores to be tree shaken 41589/*! #__NO_SIDE_EFFECTS__ */ 41590function defineStore( 41591// TODO: add proper types from above 41592idOrOptions, setup, setupOptions) { 41593 let id; 41594 let options; 41595 const isSetupStore = typeof setup === 'function'; 41596 if (typeof idOrOptions === 'string') { 41597 id = idOrOptions; 41598 // the option store setup will contain the actual options in this case 41599 options = isSetupStore ? setupOptions : setup; 41600 } 41601 else { 41602 options = idOrOptions; 41603 id = idOrOptions.id; 41604 if (( true) && typeof id !== 'string') { 41605 throw new Error(`[ð]: "defineStore()" must be passed a store id as its first argument.`); 41606 } 41607 } 41608 function useStore(pinia, hot) { 41609 const hasContext = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.hasInjectionContext)(); 41610 pinia = 41611 // in test mode, ignore the argument provided as we can always retrieve a 41612 // pinia instance with getActivePinia() 41613 ( false ? 0 : pinia) || 41614 (hasContext ? (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.inject)(piniaSymbol, null) : null); 41615 if (pinia) 41616 setActivePinia(pinia); 41617 if (( true) && !activePinia) { 41618 throw new Error(`[ð]: "getActivePinia()" was called but there was no active Pinia. Are you trying to use a store before calling "app.use(pinia)"?\n` + 41619 `See https://pinia.vuejs.org/core-concepts/outside-component-usage.html for help.\n` + 41620 `This will fail in production.`); 41621 } 41622 pinia = activePinia; 41623 if (!pinia._s.has(id)) { 41624 // creating the store registers it in `pinia._s` 41625 if (isSetupStore) { 41626 createSetupStore(id, setup, options, pinia); 41627 } 41628 else { 41629 createOptionsStore(id, options, pinia); 41630 } 41631 /* istanbul ignore else */ 41632 if ((true)) { 41633 // @ts-expect-error: not the right inferred type 41634 useStore._pinia = pinia; 41635 } 41636 } 41637 const store = pinia._s.get(id); 41638 if (( true) && hot) { 41639 const hotId = '__hot:' + id; 41640 const newStore = isSetupStore 41641 ? createSetupStore(hotId, setup, options, pinia, true) 41642 : createOptionsStore(hotId, assign({}, options), pinia, true); 41643 hot._hotUpdate(newStore); 41644 // cleanup the state properties and the store from the cache 41645 delete pinia.state.value[hotId]; 41646 pinia._s.delete(hotId); 41647 } 41648 if (( true) && IS_CLIENT) { 41649 const currentInstance = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)(); 41650 // save stores in instances to access them devtools 41651 if (currentInstance && 41652 currentInstance.proxy && 41653 // avoid adding stores that are just built for hot module replacement 41654 !hot) { 41655 const vm = currentInstance.proxy; 41656 const cache = '_pStores' in vm ? vm._pStores : (vm._pStores = {}); 41657 cache[id] = store; 41658 } 41659 } 41660 // StoreGeneric cannot be casted towards Store 41661 return store; 41662 } 41663 useStore.$id = id; 41664 return useStore; 41665} 41666 41667let mapStoreSuffix = 'Store'; 41668/** 41669 * Changes the suffix added by `mapStores()`. Can be set to an empty string. 41670 * Defaults to `"Store"`. Make sure to extend the MapStoresCustomization 41671 * interface if you are using TypeScript. 41672 * 41673 * @param suffix - new suffix 41674 */ 41675function setMapStoreSuffix(suffix // could be 'Store' but that would be annoying for JS 41676) { 41677 mapStoreSuffix = suffix; 41678} 41679/** 41680 * Allows using stores without the composition API (`setup()`) by generating an 41681 * object to be spread in the `computed` field of a component. It accepts a list 41682 * of store definitions. 41683 * 41684 * @example 41685 * ```js 41686 * export default { 41687 * computed: { 41688 * // other computed properties 41689 * ...mapStores(useUserStore, useCartStore) 41690 * }, 41691 * 41692 * created() { 41693 * this.userStore // store with id "user" 41694 * this.cartStore // store with id "cart" 41695 * } 41696 * } 41697 * ``` 41698 * 41699 * @param stores - list of stores to map to an object 41700 */ 41701function mapStores(...stores) { 41702 if (( true) && Array.isArray(stores[0])) { 41703 console.warn(`[ð]: Directly pass all stores to "mapStores()" without putting them in an array:\n` + 41704 `Replace\n` + 41705 `\tmapStores([useAuthStore, useCartStore])\n` + 41706 `with\n` + 41707 `\tmapStores(useAuthStore, useCartStore)\n` + 41708 `This will fail in production if not fixed.`); 41709 stores = stores[0]; 41710 } 41711 return stores.reduce((reduced, useStore) => { 41712 // @ts-expect-error: $id is added by defineStore 41713 reduced[useStore.$id + mapStoreSuffix] = function () { 41714 return useStore(this.$pinia); 41715 }; 41716 return reduced; 41717 }, {}); 41718} 41719/** 41720 * Allows using state and getters from one store without using the composition 41721 * API (`setup()`) by generating an object to be spread in the `computed` field 41722 * of a component. 41723 * 41724 * @param useStore - store to map from 41725 * @param keysOrMapper - array or object 41726 */ 41727function mapState(useStore, keysOrMapper) { 41728 return Array.isArray(keysOrMapper) 41729 ? keysOrMapper.reduce((reduced, key) => { 41730 reduced[key] = function () { 41731 // @ts-expect-error: FIXME: should work? 41732 return useStore(this.$pinia)[key]; 41733 }; 41734 return reduced; 41735 }, {}) 41736 : Object.keys(keysOrMapper).reduce((reduced, key) => { 41737 // @ts-expect-error 41738 reduced[key] = function () { 41739 const store = useStore(this.$pinia); 41740 const storeKey = keysOrMapper[key]; 41741 // for some reason TS is unable to infer the type of storeKey to be a 41742 // function 41743 return typeof storeKey === 'function' 41744 ? storeKey.call(this, store) 41745 : // @ts-expect-error: FIXME: should work? 41746 store[storeKey]; 41747 }; 41748 return reduced; 41749 }, {}); 41750} 41751/** 41752 * Alias for `mapState()`. You should use `mapState()` instead. 41753 * @deprecated use `mapState()` instead. 41754 */ 41755const mapGetters = mapState; 41756/** 41757 * Allows directly using actions from your store without using the composition 41758 * API (`setup()`) by generating an object to be spread in the `methods` field 41759 * of a component. 41760 * 41761 * @param useStore - store to map from 41762 * @param keysOrMapper - array or object 41763 */ 41764function mapActions(useStore, keysOrMapper) { 41765 return Array.isArray(keysOrMapper) 41766 ? keysOrMapper.reduce((reduced, key) => { 41767 // @ts-expect-error 41768 reduced[key] = function (...args) { 41769 // @ts-expect-error: FIXME: should work? 41770 return useStore(this.$pinia)[key](...args); 41771 }; 41772 return reduced; 41773 }, {}) 41774 : Object.keys(keysOrMapper).reduce((reduced, key) => { 41775 // @ts-expect-error 41776 reduced[key] = function (...args) { 41777 // @ts-expect-error: FIXME: should work? 41778 return useStore(this.$pinia)[keysOrMapper[key]](...args); 41779 }; 41780 return reduced; 41781 }, {}); 41782} 41783/** 41784 * Allows using state and getters from one store without using the composition 41785 * API (`setup()`) by generating an object to be spread in the `computed` field 41786 * of a component. 41787 * 41788 * @param useStore - store to map from 41789 * @param keysOrMapper - array or object 41790 */ 41791function mapWritableState(useStore, keysOrMapper) { 41792 return Array.isArray(keysOrMapper) 41793 ? keysOrMapper.reduce((reduced, key) => { 41794 reduced[key] = { 41795 get() { 41796 return useStore(this.$pinia)[key]; 41797 }, 41798 set(value) { 41799 return (useStore(this.$pinia)[key] = value); 41800 }, 41801 }; 41802 return reduced; 41803 }, {}) 41804 : Object.keys(keysOrMapper).reduce((reduced, key) => { 41805 reduced[key] = { 41806 get() { 41807 return useStore(this.$pinia)[keysOrMapper[key]]; 41808 }, 41809 set(value) { 41810 return (useStore(this.$pinia)[keysOrMapper[key]] = value); 41811 }, 41812 }; 41813 return reduced; 41814 }, {}); 41815} 41816 41817/** 41818 * Creates an object of references with all the state, getters, and plugin-added 41819 * state properties of the store. Similar to `toRefs()` but specifically 41820 * designed for Pinia stores so methods and non reactive properties are 41821 * completely ignored. 41822 * 41823 * @param store - store to extract the refs from 41824 */ 41825function storeToRefs(store) { 41826 // See https://github.com/vuejs/pinia/issues/852 41827 // It's easier to just use toRefs() even if it includes more stuff 41828 if (vue_demi__WEBPACK_IMPORTED_MODULE_0__.isVue2) { 41829 // @ts-expect-error: toRefs include methods and others 41830 return (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRefs)(store); 41831 } 41832 else { 41833 const rawStore = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRaw)(store); 41834 const refs = {}; 41835 for (const key in rawStore) { 41836 const value = rawStore[key]; 41837 // There is no native method to check for a computed 41838 // https://github.com/vuejs/core/pull/4165 41839 if (value.effect) { 41840 // @ts-expect-error: too hard to type correctly 41841 refs[key] = 41842 // ... 41843 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)({ 41844 get: () => store[key], 41845 set(value) { 41846 store[key] = value; 41847 }, 41848 }); 41849 } 41850 else if ((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isRef)(value) || (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isReactive)(value)) { 41851 // @ts-expect-error: the key is state or getter 41852 refs[key] = 41853 // --- 41854 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.toRef)(store, key); 41855 } 41856 } 41857 return refs; 41858 } 41859} 41860 41861/** 41862 * Vue 2 Plugin that must be installed for pinia to work. Note **you don't need 41863 * this plugin if you are using Nuxt.js**. Use the `buildModule` instead: 41864 * https://pinia.vuejs.org/ssr/nuxt.html. 41865 * 41866 * @example 41867 * ```js 41868 * import Vue from 'vue' 41869 * import { PiniaVuePlugin, createPinia } from 'pinia' 41870 * 41871 * Vue.use(PiniaVuePlugin) 41872 * const pinia = createPinia() 41873 * 41874 * new Vue({ 41875 * el: '#app', 41876 * // ... 41877 * pinia, 41878 * }) 41879 * ``` 41880 * 41881 * @param _Vue - `Vue` imported from 'vue'. 41882 */ 41883const PiniaVuePlugin = function (_Vue) { 41884 // Equivalent of 41885 // app.config.globalProperties.$pinia = pinia 41886 _Vue.mixin({ 41887 beforeCreate() { 41888 const options = this.$options; 41889 if (options.pinia) { 41890 const pinia = options.pinia; 41891 // HACK: taken from provide(): https://github.com/vuejs/composition-api/blob/main/src/apis/inject.ts#L31 41892 /* istanbul ignore else */ 41893 if (!this._provided) { 41894 const provideCache = {}; 41895 Object.defineProperty(this, '_provided', { 41896 get: () => provideCache, 41897 set: (v) => Object.assign(provideCache, v), 41898 }); 41899 } 41900 this._provided[piniaSymbol] = pinia; 41901 // propagate the pinia instance in an SSR friendly way 41902 // avoid adding it to nuxt twice 41903 /* istanbul ignore else */ 41904 if (!this.$pinia) { 41905 this.$pinia = pinia; 41906 } 41907 pinia._a = this; 41908 if (IS_CLIENT) { 41909 // this allows calling useStore() outside of a component setup after 41910 // installing pinia's plugin 41911 setActivePinia(pinia); 41912 } 41913 if (( true) && IS_CLIENT) { 41914 registerPiniaDevtools(pinia._a, pinia); 41915 } 41916 } 41917 else if (!this.$pinia && options.parent && options.parent.$pinia) { 41918 this.$pinia = options.parent.$pinia; 41919 } 41920 }, 41921 destroyed() { 41922 delete this._pStores; 41923 }, 41924 }); 41925}; 41926 41927 41928 41929 41930/***/ }), 41931
vendor: 20,437 bytes, lines 41932-42150
41932/***/ "./node_modules/vue-demi/lib/index.mjs": 41933/*!*********************************************!*\ 41934 !*** ./node_modules/vue-demi/lib/index.mjs ***! 41935 \*********************************************/ 41936/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 41937 41938"use strict"; 41939__webpack_require__.r(__webpack_exports__); 41940/* harmony export */ __webpack_require__.d(__webpack_exports__, { 41941/* harmony export */ BaseTransition: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.BaseTransition), 41942/* harmony export */ BaseTransitionPropsValidators: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.BaseTransitionPropsValidators), 41943/* harmony export */ Comment: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Comment), 41944/* harmony export */ DeprecationTypes: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.DeprecationTypes), 41945/* harmony export */ EffectScope: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.EffectScope), 41946/* harmony export */ ErrorCodes: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.ErrorCodes), 41947/* harmony export */ ErrorTypeStrings: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.ErrorTypeStrings), 41948/* harmony export */ Fragment: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Fragment), 41949/* harmony export */ KeepAlive: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.KeepAlive), 41950/* harmony export */ ReactiveEffect: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect), 41951/* harmony export */ Static: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Static), 41952/* harmony export */ Suspense: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Suspense), 41953/* harmony export */ Teleport: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Teleport), 41954/* harmony export */ Text: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Text), 41955/* harmony export */ TrackOpTypes: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.TrackOpTypes), 41956/* harmony export */ Transition: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Transition), 41957/* harmony export */ TransitionGroup: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.TransitionGroup), 41958/* harmony export */ TriggerOpTypes: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.TriggerOpTypes), 41959/* harmony export */ Vue: () => (/* reexport module object */ vue__WEBPACK_IMPORTED_MODULE_0__), 41960/* harmony export */ Vue2: () => (/* binding */ Vue2), 41961/* harmony export */ VueElement: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.VueElement), 41962/* harmony export */ assertNumber: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.assertNumber), 41963/* harmony export */ callWithAsyncErrorHandling: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling), 41964/* harmony export */ callWithErrorHandling: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.callWithErrorHandling), 41965/* harmony export */ camelize: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.camelize), 41966/* harmony export */ capitalize: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.capitalize), 41967/* harmony export */ cloneVNode: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.cloneVNode), 41968/* harmony export */ compatUtils: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.compatUtils), 41969/* harmony export */ compile: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.compile), 41970/* harmony export */ computed: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.computed), 41971/* harmony export */ createApp: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createApp), 41972/* harmony export */ createBlock: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createBlock), 41973/* harmony export */ createCommentVNode: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode), 41974/* harmony export */ createElementBlock: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock), 41975/* harmony export */ createElementVNode: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode), 41976/* harmony export */ createHydrationRenderer: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer), 41977/* harmony export */ createPropsRestProxy: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createPropsRestProxy), 41978/* harmony export */ createRenderer: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createRenderer), 41979/* harmony export */ createSSRApp: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createSSRApp), 41980/* harmony export */ createSlots: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createSlots), 41981/* harmony export */ createStaticVNode: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode), 41982/* harmony export */ createTextVNode: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode), 41983/* harmony export */ createVNode: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createVNode), 41984/* harmony export */ customRef: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.customRef), 41985/* harmony export */ defineAsyncComponent: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineAsyncComponent), 41986/* harmony export */ defineComponent: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent), 41987/* harmony export */ defineCustomElement: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineCustomElement), 41988/* harmony export */ defineEmits: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineEmits), 41989/* harmony export */ defineExpose: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineExpose), 41990/* harmony export */ defineModel: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineModel), 41991/* harmony export */ defineOptions: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineOptions), 41992/* harmony export */ defineProps: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineProps), 41993/* harmony export */ defineSSRCustomElement: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineSSRCustomElement), 41994/* harmony export */ defineSlots: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineSlots), 41995/* harmony export */ del: () => (/* binding */ del), 41996/* harmony export */ devtools: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.devtools), 41997/* harmony export */ effect: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.effect), 41998/* harmony export */ effectScope: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.effectScope), 41999/* harmony export */ getCurrentInstance: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance), 42000/* harmony export */ getCurrentScope: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope), 42001/* harmony export */ getCurrentWatcher: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentWatcher), 42002/* harmony export */ getTransitionRawChildren: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren), 42003/* harmony export */ guardReactiveProps: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.guardReactiveProps), 42004/* harmony export */ h: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.h), 42005/* harmony export */ handleError: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.handleError), 42006/* harmony export */ hasInjectionContext: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.hasInjectionContext), 42007/* harmony export */ hydrate: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.hydrate), 42008/* harmony export */ hydrateOnIdle: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.hydrateOnIdle), 42009/* harmony export */ hydrateOnInteraction: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.hydrateOnInteraction), 42010/* harmony export */ hydrateOnMediaQuery: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.hydrateOnMediaQuery), 42011/* harmony export */ hydrateOnVisible: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.hydrateOnVisible), 42012/* harmony export */ initCustomFormatter: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.initCustomFormatter), 42013/* harmony export */ initDirectivesForSSR: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.initDirectivesForSSR), 42014/* harmony export */ inject: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.inject), 42015/* harmony export */ install: () => (/* binding */ install), 42016/* harmony export */ isMemoSame: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isMemoSame), 42017/* harmony export */ isProxy: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isProxy), 42018/* harmony export */ isReactive: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isReactive), 42019/* harmony export */ isReadonly: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isReadonly), 42020/* harmony export */ isRef: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isRef), 42021/* harmony export */ isRuntimeOnly: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly), 42022/* harmony export */ isShallow: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isShallow), 42023/* harmony export */ isVNode: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isVNode), 42024/* harmony export */ isVue2: () => (/* binding */ isVue2), 42025/* harmony export */ isVue3: () => (/* binding */ isVue3), 42026/* harmony export */ markRaw: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.markRaw), 42027/* harmony export */ mergeDefaults: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.mergeDefaults), 42028/* harmony export */ mergeModels: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.mergeModels), 42029/* harmony export */ mergeProps: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.mergeProps), 42030/* harmony export */ nextTick: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.nextTick), 42031/* harmony export */ normalizeClass: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass), 42032/* harmony export */ normalizeProps: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.normalizeProps), 42033/* harmony export */ normalizeStyle: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle), 42034/* harmony export */ onActivated: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onActivated), 42035/* harmony export */ onBeforeMount: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount), 42036/* harmony export */ onBeforeUnmount: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount), 42037/* harmony export */ onBeforeUpdate: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onBeforeUpdate), 42038/* harmony export */ onDeactivated: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onDeactivated), 42039/* harmony export */ onErrorCaptured: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onErrorCaptured), 42040/* harmony export */ onMounted: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onMounted), 42041/* harmony export */ onRenderTracked: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onRenderTracked), 42042/* harmony export */ onRenderTriggered: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onRenderTriggered), 42043/* harmony export */ onScopeDispose: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose), 42044/* harmony export */ onServerPrefetch: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onServerPrefetch), 42045/* harmony export */ onUnmounted: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted), 42046/* harmony export */ onUpdated: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onUpdated), 42047/* harmony export */ onWatcherCleanup: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onWatcherCleanup), 42048/* harmony export */ openBlock: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.openBlock), 42049/* harmony export */ popScopeId: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.popScopeId), 42050/* harmony export */ provide: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.provide), 42051/* harmony export */ proxyRefs: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.proxyRefs), 42052/* harmony export */ pushScopeId: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.pushScopeId), 42053/* harmony export */ queuePostFlushCb: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.queuePostFlushCb), 42054/* harmony export */ reactive: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.reactive), 42055/* harmony export */ readonly: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.readonly), 42056/* harmony export */ ref: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.ref), 42057/* harmony export */ registerRuntimeCompiler: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeCompiler), 42058/* harmony export */ render: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.render), 42059/* harmony export */ renderList: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.renderList), 42060/* harmony export */ renderSlot: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot), 42061/* harmony export */ resolveComponent: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.resolveComponent), 42062/* harmony export */ resolveDirective: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective), 42063/* harmony export */ resolveDynamicComponent: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent), 42064/* harmony export */ resolveFilter: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.resolveFilter), 42065/* harmony export */ resolveTransitionHooks: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks), 42066/* harmony export */ set: () => (/* binding */ set), 42067/* harmony export */ setBlockTracking: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.setBlockTracking), 42068/* harmony export */ setDevtoolsHook: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.setDevtoolsHook), 42069/* harmony export */ setTransitionHooks: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks), 42070/* harmony export */ shallowReactive: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.shallowReactive), 42071/* harmony export */ shallowReadonly: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly), 42072/* harmony export */ shallowRef: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.shallowRef), 42073/* harmony export */ ssrContextKey: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.ssrContextKey), 42074/* harmony export */ ssrUtils: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.ssrUtils), 42075/* harmony export */ stop: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.stop), 42076/* harmony export */ toDisplayString: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString), 42077/* harmony export */ toHandlerKey: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey), 42078/* harmony export */ toHandlers: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toHandlers), 42079/* harmony export */ toRaw: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toRaw), 42080/* harmony export */ toRef: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toRef), 42081/* harmony export */ toRefs: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toRefs), 42082/* harmony export */ toValue: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toValue), 42083/* harmony export */ transformVNodeArgs: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.transformVNodeArgs), 42084/* harmony export */ triggerRef: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.triggerRef), 42085/* harmony export */ unref: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.unref), 42086/* harmony export */ useAttrs: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useAttrs), 42087/* harmony export */ useCssModule: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useCssModule), 42088/* harmony export */ useCssVars: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useCssVars), 42089/* harmony export */ useHost: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useHost), 42090/* harmony export */ useId: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useId), 42091/* harmony export */ useModel: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useModel), 42092/* harmony export */ useSSRContext: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useSSRContext), 42093/* harmony export */ useShadowRoot: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useShadowRoot), 42094/* harmony export */ useSlots: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useSlots), 42095/* harmony export */ useTemplateRef: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useTemplateRef), 42096/* harmony export */ useTransitionState: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useTransitionState), 42097/* harmony export */ vModelCheckbox: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vModelCheckbox), 42098/* harmony export */ vModelDynamic: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vModelDynamic), 42099/* harmony export */ vModelRadio: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vModelRadio), 42100/* harmony export */ vModelSelect: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect), 42101/* harmony export */ vModelText: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vModelText), 42102/* harmony export */ vShow: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vShow), 42103/* harmony export */ version: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.version), 42104/* harmony export */ warn: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.warn), 42105/* harmony export */ watch: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.watch), 42106/* harmony export */ watchEffect: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.watchEffect), 42107/* harmony export */ watchPostEffect: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.watchPostEffect), 42108/* harmony export */ watchSyncEffect: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.watchSyncEffect), 42109/* harmony export */ withAsyncContext: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withAsyncContext), 42110/* harmony export */ withCtx: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withCtx), 42111/* harmony export */ withDefaults: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withDefaults), 42112/* harmony export */ withDirectives: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives), 42113/* harmony export */ withKeys: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withKeys), 42114/* harmony export */ withMemo: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withMemo), 42115/* harmony export */ withModifiers: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers), 42116/* harmony export */ withScopeId: () => (/* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withScopeId) 42117/* harmony export */ }); 42118/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.esm-bundler.js"); 42119 42120 42121var isVue2 = false 42122var isVue3 = true 42123var Vue2 = undefined 42124 42125function install() {} 42126 42127function set(target, key, val) { 42128 if (Array.isArray(target)) { 42129 target.length = Math.max(target.length, key) 42130 target.splice(key, 1, val) 42131 return val 42132 } 42133 target[key] = val 42134 return val 42135} 42136 42137function del(target, key) { 42138 if (Array.isArray(target)) { 42139 target.splice(key, 1) 42140 return 42141 } 42142 delete target[key] 42143} 42144 42145 42146 42147 42148 42149/***/ }), 42150
vendor: 3,609 bytes, lines 42151-42242
42151/***/ "./node_modules/vue3-perfect-scrollbar/dist/vue3-perfect-scrollbar.js": 42152/*!****************************************************************************!*\ 42153 !*** ./node_modules/vue3-perfect-scrollbar/dist/vue3-perfect-scrollbar.js ***! 42154 \****************************************************************************/ 42155/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 42156 42157"use strict"; 42158__webpack_require__.r(__webpack_exports__); 42159/* harmony export */ __webpack_require__.d(__webpack_exports__, { 42160/* harmony export */ PerfectScrollbar: () => (/* binding */ C), 42161/* harmony export */ PerfectScrollbarPlugin: () => (/* binding */ D) 42162/* harmony export */ }); 42163/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.esm-bundler.js"); 42164/* harmony import */ var perfect_scrollbar__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! perfect-scrollbar */ "./node_modules/perfect-scrollbar/dist/perfect-scrollbar.esm.js"); 42165 42166 42167const C = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({ 42168 __name: "PerfectScrollbar", 42169 props: { 42170 tag: { default: "div" }, 42171 options: { default: () => ({}) } 42172 }, 42173 emits: ["scroll", "ps-scroll-y", "ps-scroll-x", "ps-scroll-up", "ps-scroll-down", "ps-scroll-left", "ps-scroll-right", "ps-y-reach-start", "ps-y-reach-end", "ps-x-reach-start", "ps-x-reach-end"], 42174 setup(o, { expose: n, emit: c }) { 42175 const a = o, y = c, l = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null); 42176 (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)( 42177 () => a.options, 42178 () => { 42179 i(), p(); 42180 }, 42181 { deep: !0 } 42182 ), (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => { 42183 l.value && p(); 42184 }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount)(() => { 42185 i(); 42186 }); 42187 function p() { 42188 l.value && (s.value = new perfect_scrollbar__WEBPACK_IMPORTED_MODULE_1__["default"](l.value, a.options), u()); 42189 } 42190 function i() { 42191 s.value && (u(!1), s.value.destroy(), s.value = null); 42192 } 42193 const x = { 42194 scroll: e("scroll"), 42195 "ps-scroll-y": e("ps-scroll-y"), 42196 "ps-scroll-x": e("ps-scroll-x"), 42197 "ps-scroll-up": e("ps-scroll-up"), 42198 "ps-scroll-down": e("ps-scroll-down"), 42199 "ps-scroll-left": e("ps-scroll-left"), 42200 "ps-scroll-right": e("ps-scroll-right"), 42201 "ps-y-reach-start": e("ps-y-reach-start"), 42202 "ps-y-reach-end": e("ps-y-reach-end"), 42203 "ps-x-reach-start": e("ps-x-reach-start"), 42204 "ps-x-reach-end": e("ps-x-reach-end") 42205 }; 42206 function e(r) { 42207 return function(t) { 42208 y(r, t); 42209 }; 42210 } 42211 function u(r = !0) { 42212 var t; 42213 (t = s.value) != null && t.element && Object.entries(x).forEach(([f, d]) => { 42214 var m, h; 42215 r ? (m = s.value) == null || m.element.addEventListener(f, d) : (h = s.value) == null || h.element.removeEventListener(f, d); 42216 }); 42217 } 42218 return n({ 42219 ps: s 42220 }), (r, t) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)((0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent)(r.tag), { 42221 ref_key: "scrollbar", 42222 ref: l, 42223 class: "ps" 42224 }, { 42225 default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [ 42226 (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "default") 42227 ]), 42228 _: 3 42229 }, 512)); 42230 } 42231}), O = { 42232 componentName: "PerfectScrollbar" 42233}, D = { 42234 install(o, n) { 42235 const c = Object.assign(O, n); 42236 o.component(c.componentName, C); 42237 } 42238}; 42239 42240 42241 42242/***/ })
vendor: 6 bytes, lines 42242-42244
42242 42243 42244}]);
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.