1/******/ (function() { // webpackBootstrap 2/******/ var __webpack_modules__ = ({ 3
vendor: 209,661 bytes, lines 4-5059
4/***/ "./node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js": 5/*!***************************************************************************!*\ 6 !*** ./node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js ***! 7 \***************************************************************************/ 8/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9 10"use strict"; 11__webpack_require__.r(__webpack_exports__); 12/* harmony export */ __webpack_require__.d(__webpack_exports__, { 13/* harmony export */ "BASE_TRANSITION": function() { return /* binding */ BASE_TRANSITION; }, 14/* harmony export */ "CAMELIZE": function() { return /* binding */ CAMELIZE; }, 15/* harmony export */ "CAPITALIZE": function() { return /* binding */ CAPITALIZE; }, 16/* harmony export */ "CREATE_BLOCK": function() { return /* binding */ CREATE_BLOCK; }, 17/* harmony export */ "CREATE_COMMENT": function() { return /* binding */ CREATE_COMMENT; }, 18/* harmony export */ "CREATE_ELEMENT_BLOCK": function() { return /* binding */ CREATE_ELEMENT_BLOCK; }, 19/* harmony export */ "CREATE_ELEMENT_VNODE": function() { return /* binding */ CREATE_ELEMENT_VNODE; }, 20/* harmony export */ "CREATE_SLOTS": function() { return /* binding */ CREATE_SLOTS; }, 21/* harmony export */ "CREATE_STATIC": function() { return /* binding */ CREATE_STATIC; }, 22/* harmony export */ "CREATE_TEXT": function() { return /* binding */ CREATE_TEXT; }, 23/* harmony export */ "CREATE_VNODE": function() { return /* binding */ CREATE_VNODE; }, 24/* harmony export */ "FRAGMENT": function() { return /* binding */ FRAGMENT; }, 25/* harmony export */ "GUARD_REACTIVE_PROPS": function() { return /* binding */ GUARD_REACTIVE_PROPS; }, 26/* harmony export */ "IS_MEMO_SAME": function() { return /* binding */ IS_MEMO_SAME; }, 27/* harmony export */ "IS_REF": function() { return /* binding */ IS_REF; }, 28/* harmony export */ "KEEP_ALIVE": function() { return /* binding */ KEEP_ALIVE; }, 29/* harmony export */ "MERGE_PROPS": function() { return /* binding */ MERGE_PROPS; }, 30/* harmony export */ "NORMALIZE_CLASS": function() { return /* binding */ NORMALIZE_CLASS; }, 31/* harmony export */ "NORMALIZE_PROPS": function() { return /* binding */ NORMALIZE_PROPS; }, 32/* harmony export */ "NORMALIZE_STYLE": function() { return /* binding */ NORMALIZE_STYLE; }, 33/* harmony export */ "OPEN_BLOCK": function() { return /* binding */ OPEN_BLOCK; }, 34/* harmony export */ "POP_SCOPE_ID": function() { return /* binding */ POP_SCOPE_ID; }, 35/* harmony export */ "PUSH_SCOPE_ID": function() { return /* binding */ PUSH_SCOPE_ID; }, 36/* harmony export */ "RENDER_LIST": function() { return /* binding */ RENDER_LIST; }, 37/* harmony export */ "RENDER_SLOT": function() { return /* binding */ RENDER_SLOT; }, 38/* harmony export */ "RESOLVE_COMPONENT": function() { return /* binding */ RESOLVE_COMPONENT; }, 39/* harmony export */ "RESOLVE_DIRECTIVE": function() { return /* binding */ RESOLVE_DIRECTIVE; }, 40/* harmony export */ "RESOLVE_DYNAMIC_COMPONENT": function() { return /* binding */ RESOLVE_DYNAMIC_COMPONENT; }, 41/* harmony export */ "RESOLVE_FILTER": function() { return /* binding */ RESOLVE_FILTER; }, 42/* harmony export */ "SET_BLOCK_TRACKING": function() { return /* binding */ SET_BLOCK_TRACKING; }, 43/* harmony export */ "SUSPENSE": function() { return /* binding */ SUSPENSE; }, 44/* harmony export */ "TELEPORT": function() { return /* binding */ TELEPORT; }, 45/* harmony export */ "TO_DISPLAY_STRING": function() { return /* binding */ TO_DISPLAY_STRING; }, 46/* harmony export */ "TO_HANDLERS": function() { return /* binding */ TO_HANDLERS; }, 47/* harmony export */ "TO_HANDLER_KEY": function() { return /* binding */ TO_HANDLER_KEY; }, 48/* harmony export */ "UNREF": function() { return /* binding */ UNREF; }, 49/* harmony export */ "WITH_CTX": function() { return /* binding */ WITH_CTX; }, 50/* harmony export */ "WITH_DIRECTIVES": function() { return /* binding */ WITH_DIRECTIVES; }, 51/* harmony export */ "WITH_MEMO": function() { return /* binding */ WITH_MEMO; }, 52/* harmony export */ "advancePositionWithClone": function() { return /* binding */ advancePositionWithClone; }, 53/* harmony export */ "advancePositionWithMutation": function() { return /* binding */ advancePositionWithMutation; }, 54/* harmony export */ "assert": function() { return /* binding */ assert; }, 55/* harmony export */ "baseCompile": function() { return /* binding */ baseCompile; }, 56/* harmony export */ "baseParse": function() { return /* binding */ baseParse; }, 57/* harmony export */ "buildDirectiveArgs": function() { return /* binding */ buildDirectiveArgs; }, 58/* harmony export */ "buildProps": function() { return /* binding */ buildProps; }, 59/* harmony export */ "buildSlots": function() { return /* binding */ buildSlots; }, 60/* harmony export */ "checkCompatEnabled": function() { return /* binding */ checkCompatEnabled; }, 61/* harmony export */ "createArrayExpression": function() { return /* binding */ createArrayExpression; }, 62/* harmony export */ "createAssignmentExpression": function() { return /* binding */ createAssignmentExpression; }, 63/* harmony export */ "createBlockStatement": function() { return /* binding */ createBlockStatement; }, 64/* harmony export */ "createCacheExpression": function() { return /* binding */ createCacheExpression; }, 65/* harmony export */ "createCallExpression": function() { return /* binding */ createCallExpression; }, 66/* harmony export */ "createCompilerError": function() { return /* binding */ createCompilerError; }, 67/* harmony export */ "createCompoundExpression": function() { return /* binding */ createCompoundExpression; }, 68/* harmony export */ "createConditionalExpression": function() { return /* binding */ createConditionalExpression; }, 69/* harmony export */ "createForLoopParams": function() { return /* binding */ createForLoopParams; }, 70/* harmony export */ "createFunctionExpression": function() { return /* binding */ createFunctionExpression; }, 71/* harmony export */ "createIfStatement": function() { return /* binding */ createIfStatement; }, 72/* harmony export */ "createInterpolation": function() { return /* binding */ createInterpolation; }, 73/* harmony export */ "createObjectExpression": function() { return /* binding */ createObjectExpression; }, 74/* harmony export */ "createObjectProperty": function() { return /* binding */ createObjectProperty; }, 75/* harmony export */ "createReturnStatement": function() { return /* binding */ createReturnStatement; }, 76/* harmony export */ "createRoot": function() { return /* binding */ createRoot; }, 77/* harmony export */ "createSequenceExpression": function() { return /* binding */ createSequenceExpression; }, 78/* harmony export */ "createSimpleExpression": function() { return /* binding */ createSimpleExpression; }, 79/* harmony export */ "createStructuralDirectiveTransform": function() { return /* binding */ createStructuralDirectiveTransform; }, 80/* harmony export */ "createTemplateLiteral": function() { return /* binding */ createTemplateLiteral; }, 81/* harmony export */ "createTransformContext": function() { return /* binding */ createTransformContext; }, 82/* harmony export */ "createVNodeCall": function() { return /* binding */ createVNodeCall; }, 83/* harmony export */ "extractIdentifiers": function() { return /* binding */ extractIdentifiers; }, 84/* harmony export */ "findDir": function() { return /* binding */ findDir; }, 85/* harmony export */ "findProp": function() { return /* binding */ findProp; }, 86/* harmony export */ "generate": function() { return /* binding */ generate; }, 87/* harmony export */ "generateCodeFrame": function() { return /* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_0__.generateCodeFrame; }, 88/* harmony export */ "getBaseTransformPreset": function() { return /* binding */ getBaseTransformPreset; }, 89/* harmony export */ "getConstantType": function() { return /* binding */ getConstantType; }, 90/* harmony export */ "getInnerRange": function() { return /* binding */ getInnerRange; }, 91/* harmony export */ "getMemoedVNodeCall": function() { return /* binding */ getMemoedVNodeCall; }, 92/* harmony export */ "getVNodeBlockHelper": function() { return /* binding */ getVNodeBlockHelper; }, 93/* harmony export */ "getVNodeHelper": function() { return /* binding */ getVNodeHelper; }, 94/* harmony export */ "hasDynamicKeyVBind": function() { return /* binding */ hasDynamicKeyVBind; }, 95/* harmony export */ "hasScopeRef": function() { return /* binding */ hasScopeRef; }, 96/* harmony export */ "helperNameMap": function() { return /* binding */ helperNameMap; }, 97/* harmony export */ "injectProp": function() { return /* binding */ injectProp; }, 98/* harmony export */ "isBuiltInType": function() { return /* binding */ isBuiltInType; }, 99/* harmony export */ "isCoreComponent": function() { return /* binding */ isCoreComponent; }, 100/* harmony export */ "isFunctionType": function() { return /* binding */ isFunctionType; }, 101/* harmony export */ "isInDestructureAssignment": function() { return /* binding */ isInDestructureAssignment; }, 102/* harmony export */ "isMemberExpression": function() { return /* binding */ isMemberExpression; }, 103/* harmony export */ "isMemberExpressionBrowser": function() { return /* binding */ isMemberExpressionBrowser; }, 104/* harmony export */ "isMemberExpressionNode": function() { return /* binding */ isMemberExpressionNode; }, 105/* harmony export */ "isReferencedIdentifier": function() { return /* binding */ isReferencedIdentifier; }, 106/* harmony export */ "isSimpleIdentifier": function() { return /* binding */ isSimpleIdentifier; }, 107/* harmony export */ "isSlotOutlet": function() { return /* binding */ isSlotOutlet; }, 108/* harmony export */ "isStaticArgOf": function() { return /* binding */ isStaticArgOf; }, 109/* harmony export */ "isStaticExp": function() { return /* binding */ isStaticExp; }, 110/* harmony export */ "isStaticProperty": function() { return /* binding */ isStaticProperty; }, 111/* harmony export */ "isStaticPropertyKey": function() { return /* binding */ isStaticPropertyKey; }, 112/* harmony export */ "isTemplateNode": function() { return /* binding */ isTemplateNode; }, 113/* harmony export */ "isText": function() { return /* binding */ isText; }, 114/* harmony export */ "isVSlot": function() { return /* binding */ isVSlot; }, 115/* harmony export */ "locStub": function() { return /* binding */ locStub; }, 116/* harmony export */ "makeBlock": function() { return /* binding */ makeBlock; }, 117/* harmony export */ "noopDirectiveTransform": function() { return /* binding */ noopDirectiveTransform; }, 118/* harmony export */ "processExpression": function() { return /* binding */ processExpression; }, 119/* harmony export */ "processFor": function() { return /* binding */ processFor; }, 120/* harmony export */ "processIf": function() { return /* binding */ processIf; }, 121/* harmony export */ "processSlotOutlet": function() { return /* binding */ processSlotOutlet; }, 122/* harmony export */ "registerRuntimeHelpers": function() { return /* binding */ registerRuntimeHelpers; }, 123/* harmony export */ "resolveComponentType": function() { return /* binding */ resolveComponentType; }, 124/* harmony export */ "stringifyExpression": function() { return /* binding */ stringifyExpression; }, 125/* harmony export */ "toValidAssetId": function() { return /* binding */ toValidAssetId; }, 126/* harmony export */ "trackSlotScopes": function() { return /* binding */ trackSlotScopes; }, 127/* harmony export */ "trackVForSlotScopes": function() { return /* binding */ trackVForSlotScopes; }, 128/* harmony export */ "transform": function() { return /* binding */ transform; }, 129/* harmony export */ "transformBind": function() { return /* binding */ transformBind; }, 130/* harmony export */ "transformElement": function() { return /* binding */ transformElement; }, 131/* harmony export */ "transformExpression": function() { return /* binding */ transformExpression; }, 132/* harmony export */ "transformModel": function() { return /* binding */ transformModel; }, 133/* harmony export */ "transformOn": function() { return /* binding */ transformOn; }, 134/* harmony export */ "traverseNode": function() { return /* binding */ traverseNode; }, 135/* harmony export */ "walkBlockDeclarations": function() { return /* binding */ walkBlockDeclarations; }, 136/* harmony export */ "walkFunctionParams": function() { return /* binding */ walkFunctionParams; }, 137/* harmony export */ "walkIdentifiers": function() { return /* binding */ walkIdentifiers; }, 138/* harmony export */ "warnDeprecation": function() { return /* binding */ warnDeprecation; } 139/* harmony export */ }); 140/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 141 142 143 144function defaultOnError(error) { 145 throw error; 146} 147function defaultOnWarn(msg) { 148 ( true) && console.warn(`[Vue warn] ${msg.message}`); 149} 150function createCompilerError(code, loc, messages, additionalMessage) { 151 const msg = true 152 ? (messages || errorMessages)[code] + (additionalMessage || ``) 153 : 0; 154 const error = new SyntaxError(String(msg)); 155 error.code = code; 156 error.loc = loc; 157 return error; 158} 159const errorMessages = { 160 // parse errors 161 [0 /* ErrorCodes.ABRUPT_CLOSING_OF_EMPTY_COMMENT */]: 'Illegal comment.', 162 [1 /* ErrorCodes.CDATA_IN_HTML_CONTENT */]: 'CDATA section is allowed only in XML context.', 163 [2 /* ErrorCodes.DUPLICATE_ATTRIBUTE */]: 'Duplicate attribute.', 164 [3 /* ErrorCodes.END_TAG_WITH_ATTRIBUTES */]: 'End tag cannot have attributes.', 165 [4 /* ErrorCodes.END_TAG_WITH_TRAILING_SOLIDUS */]: "Illegal '/' in tags.", 166 [5 /* ErrorCodes.EOF_BEFORE_TAG_NAME */]: 'Unexpected EOF in tag.', 167 [6 /* ErrorCodes.EOF_IN_CDATA */]: 'Unexpected EOF in CDATA section.', 168 [7 /* ErrorCodes.EOF_IN_COMMENT */]: 'Unexpected EOF in comment.', 169 [8 /* ErrorCodes.EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT */]: 'Unexpected EOF in script.', 170 [9 /* ErrorCodes.EOF_IN_TAG */]: 'Unexpected EOF in tag.', 171 [10 /* ErrorCodes.INCORRECTLY_CLOSED_COMMENT */]: 'Incorrectly closed comment.', 172 [11 /* ErrorCodes.INCORRECTLY_OPENED_COMMENT */]: 'Incorrectly opened comment.', 173 [12 /* ErrorCodes.INVALID_FIRST_CHARACTER_OF_TAG_NAME */]: "Illegal tag name. Use '<' to print '<'.", 174 [13 /* ErrorCodes.MISSING_ATTRIBUTE_VALUE */]: 'Attribute value was expected.', 175 [14 /* ErrorCodes.MISSING_END_TAG_NAME */]: 'End tag name was expected.', 176 [15 /* ErrorCodes.MISSING_WHITESPACE_BETWEEN_ATTRIBUTES */]: 'Whitespace was expected.', 177 [16 /* ErrorCodes.NESTED_COMMENT */]: "Unexpected '<!--' in comment.", 178 [17 /* ErrorCodes.UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME */]: 'Attribute name cannot contain U+0022 ("), U+0027 (\'), and U+003C (<).', 179 [18 /* ErrorCodes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE */]: 'Unquoted attribute value cannot contain U+0022 ("), U+0027 (\'), U+003C (<), U+003D (=), and U+0060 (`).', 180 [19 /* ErrorCodes.UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME */]: "Attribute name cannot start with '='.", 181 [21 /* ErrorCodes.UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME */]: "'<?' is allowed only in XML context.", 182 [20 /* ErrorCodes.UNEXPECTED_NULL_CHARACTER */]: `Unexpected null character.`, 183 [22 /* ErrorCodes.UNEXPECTED_SOLIDUS_IN_TAG */]: "Illegal '/' in tags.", 184 // Vue-specific parse errors 185 [23 /* ErrorCodes.X_INVALID_END_TAG */]: 'Invalid end tag.', 186 [24 /* ErrorCodes.X_MISSING_END_TAG */]: 'Element is missing end tag.', 187 [25 /* ErrorCodes.X_MISSING_INTERPOLATION_END */]: 'Interpolation end sign was not found.', 188 [27 /* ErrorCodes.X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END */]: 'End bracket for dynamic directive argument was not found. ' + 189 'Note that dynamic directive argument cannot contain spaces.', 190 [26 /* ErrorCodes.X_MISSING_DIRECTIVE_NAME */]: 'Legal directive name was expected.', 191 // transform errors 192 [28 /* ErrorCodes.X_V_IF_NO_EXPRESSION */]: `v-if/v-else-if is missing expression.`, 193 [29 /* ErrorCodes.X_V_IF_SAME_KEY */]: `v-if/else branches must use unique keys.`, 194 [30 /* ErrorCodes.X_V_ELSE_NO_ADJACENT_IF */]: `v-else/v-else-if has no adjacent v-if or v-else-if.`, 195 [31 /* ErrorCodes.X_V_FOR_NO_EXPRESSION */]: `v-for is missing expression.`, 196 [32 /* ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION */]: `v-for has invalid expression.`, 197 [33 /* ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT */]: `<template v-for> key should be placed on the <template> tag.`, 198 [34 /* ErrorCodes.X_V_BIND_NO_EXPRESSION */]: `v-bind is missing expression.`, 199 [35 /* ErrorCodes.X_V_ON_NO_EXPRESSION */]: `v-on is missing expression.`, 200 [36 /* ErrorCodes.X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */]: `Unexpected custom directive on <slot> outlet.`, 201 [37 /* ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE */]: `Mixed v-slot usage on both the component and nested <template>.` + 202 `When there are multiple named slots, all slots should use <template> ` + 203 `syntax to avoid scope ambiguity.`, 204 [38 /* ErrorCodes.X_V_SLOT_DUPLICATE_SLOT_NAMES */]: `Duplicate slot names found. `, 205 [39 /* ErrorCodes.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN */]: `Extraneous children found when component already has explicitly named ` + 206 `default slot. These children will be ignored.`, 207 [40 /* ErrorCodes.X_V_SLOT_MISPLACED */]: `v-slot can only be used on components or <template> tags.`, 208 [41 /* ErrorCodes.X_V_MODEL_NO_EXPRESSION */]: `v-model is missing expression.`, 209 [42 /* ErrorCodes.X_V_MODEL_MALFORMED_EXPRESSION */]: `v-model value must be a valid JavaScript member expression.`, 210 [43 /* ErrorCodes.X_V_MODEL_ON_SCOPE_VARIABLE */]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`, 211 [44 /* ErrorCodes.X_V_MODEL_ON_PROPS */]: `v-model cannot be used on a prop, because local prop bindings are not writable.\nUse a v-bind binding combined with a v-on listener that emits update:x event instead.`, 212 [45 /* ErrorCodes.X_INVALID_EXPRESSION */]: `Error parsing JavaScript expression: `, 213 [46 /* ErrorCodes.X_KEEP_ALIVE_INVALID_CHILDREN */]: `<KeepAlive> expects exactly one child component.`, 214 // generic errors 215 [47 /* ErrorCodes.X_PREFIX_ID_NOT_SUPPORTED */]: `"prefixIdentifiers" option is not supported in this build of compiler.`, 216 [48 /* ErrorCodes.X_MODULE_MODE_NOT_SUPPORTED */]: `ES module mode is not supported in this build of compiler.`, 217 [49 /* ErrorCodes.X_CACHE_HANDLER_NOT_SUPPORTED */]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`, 218 [50 /* ErrorCodes.X_SCOPE_ID_NOT_SUPPORTED */]: `"scopeId" option is only supported in module mode.`, 219 // just to fulfill types 220 [51 /* ErrorCodes.__EXTEND_POINT__ */]: `` 221}; 222 223const FRAGMENT = Symbol(( true) ? `Fragment` : 0); 224const TELEPORT = Symbol(( true) ? `Teleport` : 0); 225const SUSPENSE = Symbol(( true) ? `Suspense` : 0); 226const KEEP_ALIVE = Symbol(( true) ? `KeepAlive` : 0); 227const BASE_TRANSITION = Symbol(( true) ? `BaseTransition` : 0); 228const OPEN_BLOCK = Symbol(( true) ? `openBlock` : 0); 229const CREATE_BLOCK = Symbol(( true) ? `createBlock` : 0); 230const CREATE_ELEMENT_BLOCK = Symbol(( true) ? `createElementBlock` : 0); 231const CREATE_VNODE = Symbol(( true) ? `createVNode` : 0); 232const CREATE_ELEMENT_VNODE = Symbol(( true) ? `createElementVNode` : 0); 233const CREATE_COMMENT = Symbol(( true) ? `createCommentVNode` : 0); 234const CREATE_TEXT = Symbol(( true) ? `createTextVNode` : 0); 235const CREATE_STATIC = Symbol(( true) ? `createStaticVNode` : 0); 236const RESOLVE_COMPONENT = Symbol(( true) ? `resolveComponent` : 0); 237const RESOLVE_DYNAMIC_COMPONENT = Symbol(( true) ? `resolveDynamicComponent` : 0); 238const RESOLVE_DIRECTIVE = Symbol(( true) ? `resolveDirective` : 0); 239const RESOLVE_FILTER = Symbol(( true) ? `resolveFilter` : 0); 240const WITH_DIRECTIVES = Symbol(( true) ? `withDirectives` : 0); 241const RENDER_LIST = Symbol(( true) ? `renderList` : 0); 242const RENDER_SLOT = Symbol(( true) ? `renderSlot` : 0); 243const CREATE_SLOTS = Symbol(( true) ? `createSlots` : 0); 244const TO_DISPLAY_STRING = Symbol(( true) ? `toDisplayString` : 0); 245const MERGE_PROPS = Symbol(( true) ? `mergeProps` : 0); 246const NORMALIZE_CLASS = Symbol(( true) ? `normalizeClass` : 0); 247const NORMALIZE_STYLE = Symbol(( true) ? `normalizeStyle` : 0); 248const NORMALIZE_PROPS = Symbol(( true) ? `normalizeProps` : 0); 249const GUARD_REACTIVE_PROPS = Symbol(( true) ? `guardReactiveProps` : 0); 250const TO_HANDLERS = Symbol(( true) ? `toHandlers` : 0); 251const CAMELIZE = Symbol(( true) ? `camelize` : 0); 252const CAPITALIZE = Symbol(( true) ? `capitalize` : 0); 253const TO_HANDLER_KEY = Symbol(( true) ? `toHandlerKey` : 0); 254const SET_BLOCK_TRACKING = Symbol(( true) ? `setBlockTracking` : 0); 255const PUSH_SCOPE_ID = Symbol(( true) ? `pushScopeId` : 0); 256const POP_SCOPE_ID = Symbol(( true) ? `popScopeId` : 0); 257const WITH_CTX = Symbol(( true) ? `withCtx` : 0); 258const UNREF = Symbol(( true) ? `unref` : 0); 259const IS_REF = Symbol(( true) ? `isRef` : 0); 260const WITH_MEMO = Symbol(( true) ? `withMemo` : 0); 261const IS_MEMO_SAME = Symbol(( true) ? `isMemoSame` : 0); 262// Name mapping for runtime helpers that need to be imported from 'vue' in 263// generated code. Make sure these are correctly exported in the runtime! 264const helperNameMap = { 265 [FRAGMENT]: `Fragment`, 266 [TELEPORT]: `Teleport`, 267 [SUSPENSE]: `Suspense`, 268 [KEEP_ALIVE]: `KeepAlive`, 269 [BASE_TRANSITION]: `BaseTransition`, 270 [OPEN_BLOCK]: `openBlock`, 271 [CREATE_BLOCK]: `createBlock`, 272 [CREATE_ELEMENT_BLOCK]: `createElementBlock`, 273 [CREATE_VNODE]: `createVNode`, 274 [CREATE_ELEMENT_VNODE]: `createElementVNode`, 275 [CREATE_COMMENT]: `createCommentVNode`, 276 [CREATE_TEXT]: `createTextVNode`, 277 [CREATE_STATIC]: `createStaticVNode`, 278 [RESOLVE_COMPONENT]: `resolveComponent`, 279 [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`, 280 [RESOLVE_DIRECTIVE]: `resolveDirective`, 281 [RESOLVE_FILTER]: `resolveFilter`, 282 [WITH_DIRECTIVES]: `withDirectives`, 283 [RENDER_LIST]: `renderList`, 284 [RENDER_SLOT]: `renderSlot`, 285 [CREATE_SLOTS]: `createSlots`, 286 [TO_DISPLAY_STRING]: `toDisplayString`, 287 [MERGE_PROPS]: `mergeProps`, 288 [NORMALIZE_CLASS]: `normalizeClass`, 289 [NORMALIZE_STYLE]: `normalizeStyle`, 290 [NORMALIZE_PROPS]: `normalizeProps`, 291 [GUARD_REACTIVE_PROPS]: `guardReactiveProps`, 292 [TO_HANDLERS]: `toHandlers`, 293 [CAMELIZE]: `camelize`, 294 [CAPITALIZE]: `capitalize`, 295 [TO_HANDLER_KEY]: `toHandlerKey`, 296 [SET_BLOCK_TRACKING]: `setBlockTracking`, 297 [PUSH_SCOPE_ID]: `pushScopeId`, 298 [POP_SCOPE_ID]: `popScopeId`, 299 [WITH_CTX]: `withCtx`, 300 [UNREF]: `unref`, 301 [IS_REF]: `isRef`, 302 [WITH_MEMO]: `withMemo`, 303 [IS_MEMO_SAME]: `isMemoSame` 304}; 305function registerRuntimeHelpers(helpers) { 306 Object.getOwnPropertySymbols(helpers).forEach(s => { 307 helperNameMap[s] = helpers[s]; 308 }); 309} 310 311// AST Utilities --------------------------------------------------------------- 312// Some expressions, e.g. sequence and conditional expressions, are never 313// associated with template nodes, so their source locations are just a stub. 314// Container types like CompoundExpression also don't need a real location. 315const locStub = { 316 source: '', 317 start: { line: 1, column: 1, offset: 0 }, 318 end: { line: 1, column: 1, offset: 0 } 319}; 320function createRoot(children, loc = locStub) { 321 return { 322 type: 0 /* NodeTypes.ROOT */, 323 children, 324 helpers: [], 325 components: [], 326 directives: [], 327 hoists: [], 328 imports: [], 329 cached: 0, 330 temps: 0, 331 codegenNode: undefined, 332 loc 333 }; 334} 335function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) { 336 if (context) { 337 if (isBlock) { 338 context.helper(OPEN_BLOCK); 339 context.helper(getVNodeBlockHelper(context.inSSR, isComponent)); 340 } 341 else { 342 context.helper(getVNodeHelper(context.inSSR, isComponent)); 343 } 344 if (directives) { 345 context.helper(WITH_DIRECTIVES); 346 } 347 } 348 return { 349 type: 13 /* NodeTypes.VNODE_CALL */, 350 tag, 351 props, 352 children, 353 patchFlag, 354 dynamicProps, 355 directives, 356 isBlock, 357 disableTracking, 358 isComponent, 359 loc 360 }; 361} 362function createArrayExpression(elements, loc = locStub) { 363 return { 364 type: 17 /* NodeTypes.JS_ARRAY_EXPRESSION */, 365 loc, 366 elements 367 }; 368} 369function createObjectExpression(properties, loc = locStub) { 370 return { 371 type: 15 /* NodeTypes.JS_OBJECT_EXPRESSION */, 372 loc, 373 properties 374 }; 375} 376function createObjectProperty(key, value) { 377 return { 378 type: 16 /* NodeTypes.JS_PROPERTY */, 379 loc: locStub, 380 key: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(key) ? createSimpleExpression(key, true) : key, 381 value 382 }; 383} 384function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0 /* ConstantTypes.NOT_CONSTANT */) { 385 return { 386 type: 4 /* NodeTypes.SIMPLE_EXPRESSION */, 387 loc, 388 content, 389 isStatic, 390 constType: isStatic ? 3 /* ConstantTypes.CAN_STRINGIFY */ : constType 391 }; 392} 393function createInterpolation(content, loc) { 394 return { 395 type: 5 /* NodeTypes.INTERPOLATION */, 396 loc, 397 content: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(content) 398 ? createSimpleExpression(content, false, loc) 399 : content 400 }; 401} 402function createCompoundExpression(children, loc = locStub) { 403 return { 404 type: 8 /* NodeTypes.COMPOUND_EXPRESSION */, 405 loc, 406 children 407 }; 408} 409function createCallExpression(callee, args = [], loc = locStub) { 410 return { 411 type: 14 /* NodeTypes.JS_CALL_EXPRESSION */, 412 loc, 413 callee, 414 arguments: args 415 }; 416} 417function createFunctionExpression(params, returns = undefined, newline = false, isSlot = false, loc = locStub) { 418 return { 419 type: 18 /* NodeTypes.JS_FUNCTION_EXPRESSION */, 420 params, 421 returns, 422 newline, 423 isSlot, 424 loc 425 }; 426} 427function createConditionalExpression(test, consequent, alternate, newline = true) { 428 return { 429 type: 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */, 430 test, 431 consequent, 432 alternate, 433 newline, 434 loc: locStub 435 }; 436} 437function createCacheExpression(index, value, isVNode = false) { 438 return { 439 type: 20 /* NodeTypes.JS_CACHE_EXPRESSION */, 440 index, 441 value, 442 isVNode, 443 loc: locStub 444 }; 445} 446function createBlockStatement(body) { 447 return { 448 type: 21 /* NodeTypes.JS_BLOCK_STATEMENT */, 449 body, 450 loc: locStub 451 }; 452} 453function createTemplateLiteral(elements) { 454 return { 455 type: 22 /* NodeTypes.JS_TEMPLATE_LITERAL */, 456 elements, 457 loc: locStub 458 }; 459} 460function createIfStatement(test, consequent, alternate) { 461 return { 462 type: 23 /* NodeTypes.JS_IF_STATEMENT */, 463 test, 464 consequent, 465 alternate, 466 loc: locStub 467 }; 468} 469function createAssignmentExpression(left, right) { 470 return { 471 type: 24 /* NodeTypes.JS_ASSIGNMENT_EXPRESSION */, 472 left, 473 right, 474 loc: locStub 475 }; 476} 477function createSequenceExpression(expressions) { 478 return { 479 type: 25 /* NodeTypes.JS_SEQUENCE_EXPRESSION */, 480 expressions, 481 loc: locStub 482 }; 483} 484function createReturnStatement(returns) { 485 return { 486 type: 26 /* NodeTypes.JS_RETURN_STATEMENT */, 487 returns, 488 loc: locStub 489 }; 490} 491 492const isStaticExp = (p) => p.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && p.isStatic; 493const isBuiltInType = (tag, expected) => tag === expected || tag === (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hyphenate)(expected); 494function isCoreComponent(tag) { 495 if (isBuiltInType(tag, 'Teleport')) { 496 return TELEPORT; 497 } 498 else if (isBuiltInType(tag, 'Suspense')) { 499 return SUSPENSE; 500 } 501 else if (isBuiltInType(tag, 'KeepAlive')) { 502 return KEEP_ALIVE; 503 } 504 else if (isBuiltInType(tag, 'BaseTransition')) { 505 return BASE_TRANSITION; 506 } 507} 508const nonIdentifierRE = /^\d|[^\$\w]/; 509const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name); 510const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/; 511const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/; 512const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g; 513/** 514 * Simple lexer to check if an expression is a member expression. This is 515 * lax and only checks validity at the root level (i.e. does not validate exps 516 * inside square brackets), but it's ok since these are only used on template 517 * expressions and false positives are invalid expressions in the first place. 518 */ 519const isMemberExpressionBrowser = (path) => { 520 // remove whitespaces around . or [ first 521 path = path.trim().replace(whitespaceRE, s => s.trim()); 522 let state = 0 /* MemberExpLexState.inMemberExp */; 523 let stateStack = []; 524 let currentOpenBracketCount = 0; 525 let currentOpenParensCount = 0; 526 let currentStringType = null; 527 for (let i = 0; i < path.length; i++) { 528 const char = path.charAt(i); 529 switch (state) { 530 case 0 /* MemberExpLexState.inMemberExp */: 531 if (char === '[') { 532 stateStack.push(state); 533 state = 1 /* MemberExpLexState.inBrackets */; 534 currentOpenBracketCount++; 535 } 536 else if (char === '(') { 537 stateStack.push(state); 538 state = 2 /* MemberExpLexState.inParens */; 539 currentOpenParensCount++; 540 } 541 else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) { 542 return false; 543 } 544 break; 545 case 1 /* MemberExpLexState.inBrackets */: 546 if (char === `'` || char === `"` || char === '`') { 547 stateStack.push(state); 548 state = 3 /* MemberExpLexState.inString */; 549 currentStringType = char; 550 } 551 else if (char === `[`) { 552 currentOpenBracketCount++; 553 } 554 else if (char === `]`) { 555 if (!--currentOpenBracketCount) { 556 state = stateStack.pop(); 557 } 558 } 559 break; 560 case 2 /* MemberExpLexState.inParens */: 561 if (char === `'` || char === `"` || char === '`') { 562 stateStack.push(state); 563 state = 3 /* MemberExpLexState.inString */; 564 currentStringType = char; 565 } 566 else if (char === `(`) { 567 currentOpenParensCount++; 568 } 569 else if (char === `)`) { 570 // if the exp ends as a call then it should not be considered valid 571 if (i === path.length - 1) { 572 return false; 573 } 574 if (!--currentOpenParensCount) { 575 state = stateStack.pop(); 576 } 577 } 578 break; 579 case 3 /* MemberExpLexState.inString */: 580 if (char === currentStringType) { 581 state = stateStack.pop(); 582 currentStringType = null; 583 } 584 break; 585 } 586 } 587 return !currentOpenBracketCount && !currentOpenParensCount; 588}; 589const isMemberExpressionNode = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP 590 ; 591const isMemberExpression = isMemberExpressionBrowser 592 ; 593function getInnerRange(loc, offset, length) { 594 const source = loc.source.slice(offset, offset + length); 595 const newLoc = { 596 source, 597 start: advancePositionWithClone(loc.start, loc.source, offset), 598 end: loc.end 599 }; 600 if (length != null) { 601 newLoc.end = advancePositionWithClone(loc.start, loc.source, offset + length); 602 } 603 return newLoc; 604} 605function advancePositionWithClone(pos, source, numberOfCharacters = source.length) { 606 return advancePositionWithMutation((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, pos), source, numberOfCharacters); 607} 608// advance by mutation without cloning (for performance reasons), since this 609// gets called a lot in the parser 610function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) { 611 let linesCount = 0; 612 let lastNewLinePos = -1; 613 for (let i = 0; i < numberOfCharacters; i++) { 614 if (source.charCodeAt(i) === 10 /* newline char code */) { 615 linesCount++; 616 lastNewLinePos = i; 617 } 618 } 619 pos.offset += numberOfCharacters; 620 pos.line += linesCount; 621 pos.column = 622 lastNewLinePos === -1 623 ? pos.column + numberOfCharacters 624 : numberOfCharacters - lastNewLinePos; 625 return pos; 626} 627function assert(condition, msg) { 628 /* istanbul ignore if */ 629 if (!condition) { 630 throw new Error(msg || `unexpected compiler condition`); 631 } 632} 633function findDir(node, name, allowEmpty = false) { 634 for (let i = 0; i < node.props.length; i++) { 635 const p = node.props[i]; 636 if (p.type === 7 /* NodeTypes.DIRECTIVE */ && 637 (allowEmpty || p.exp) && 638 ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(name) ? p.name === name : name.test(p.name))) { 639 return p; 640 } 641 } 642} 643function findProp(node, name, dynamicOnly = false, allowEmpty = false) { 644 for (let i = 0; i < node.props.length; i++) { 645 const p = node.props[i]; 646 if (p.type === 6 /* NodeTypes.ATTRIBUTE */) { 647 if (dynamicOnly) 648 continue; 649 if (p.name === name && (p.value || allowEmpty)) { 650 return p; 651 } 652 } 653 else if (p.name === 'bind' && 654 (p.exp || allowEmpty) && 655 isStaticArgOf(p.arg, name)) { 656 return p; 657 } 658 } 659} 660function isStaticArgOf(arg, name) { 661 return !!(arg && isStaticExp(arg) && arg.content === name); 662} 663function hasDynamicKeyVBind(node) { 664 return node.props.some(p => p.type === 7 /* NodeTypes.DIRECTIVE */ && 665 p.name === 'bind' && 666 (!p.arg || // v-bind="obj" 667 p.arg.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */ || // v-bind:[_ctx.foo] 668 !p.arg.isStatic) // v-bind:[foo] 669 ); 670} 671function isText(node) { 672 return node.type === 5 /* NodeTypes.INTERPOLATION */ || node.type === 2 /* NodeTypes.TEXT */; 673} 674function isVSlot(p) { 675 return p.type === 7 /* NodeTypes.DIRECTIVE */ && p.name === 'slot'; 676} 677function isTemplateNode(node) { 678 return (node.type === 1 /* NodeTypes.ELEMENT */ && node.tagType === 3 /* ElementTypes.TEMPLATE */); 679} 680function isSlotOutlet(node) { 681 return node.type === 1 /* NodeTypes.ELEMENT */ && node.tagType === 2 /* ElementTypes.SLOT */; 682} 683function getVNodeHelper(ssr, isComponent) { 684 return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE; 685} 686function getVNodeBlockHelper(ssr, isComponent) { 687 return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK; 688} 689const propsHelperSet = new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]); 690function getUnnormalizedProps(props, callPath = []) { 691 if (props && 692 !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(props) && 693 props.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) { 694 const callee = props.callee; 695 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(callee) && propsHelperSet.has(callee)) { 696 return getUnnormalizedProps(props.arguments[0], callPath.concat(props)); 697 } 698 } 699 return [props, callPath]; 700} 701function injectProp(node, prop, context) { 702 let propsWithInjection; 703 /** 704 * 1. mergeProps(...) 705 * 2. toHandlers(...) 706 * 3. normalizeProps(...) 707 * 4. normalizeProps(guardReactiveProps(...)) 708 * 709 * we need to get the real props before normalization 710 */ 711 let props = node.type === 13 /* NodeTypes.VNODE_CALL */ ? node.props : node.arguments[2]; 712 let callPath = []; 713 let parentCall; 714 if (props && 715 !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(props) && 716 props.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) { 717 const ret = getUnnormalizedProps(props); 718 props = ret[0]; 719 callPath = ret[1]; 720 parentCall = callPath[callPath.length - 1]; 721 } 722 if (props == null || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(props)) { 723 propsWithInjection = createObjectExpression([prop]); 724 } 725 else if (props.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) { 726 // merged props... add ours 727 // only inject key to object literal if it's the first argument so that 728 // if doesn't override user provided keys 729 const first = props.arguments[0]; 730 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(first) && first.type === 15 /* NodeTypes.JS_OBJECT_EXPRESSION */) { 731 // #6631 732 if (!hasProp(prop, first)) { 733 first.properties.unshift(prop); 734 } 735 } 736 else { 737 if (props.callee === TO_HANDLERS) { 738 // #2366 739 propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [ 740 createObjectExpression([prop]), 741 props 742 ]); 743 } 744 else { 745 props.arguments.unshift(createObjectExpression([prop])); 746 } 747 } 748 !propsWithInjection && (propsWithInjection = props); 749 } 750 else if (props.type === 15 /* NodeTypes.JS_OBJECT_EXPRESSION */) { 751 if (!hasProp(prop, props)) { 752 props.properties.unshift(prop); 753 } 754 propsWithInjection = props; 755 } 756 else { 757 // single v-bind with expression, return a merged replacement 758 propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [ 759 createObjectExpression([prop]), 760 props 761 ]); 762 // in the case of nested helper call, e.g. `normalizeProps(guardReactiveProps(props))`, 763 // it will be rewritten as `normalizeProps(mergeProps({ key: 0 }, props))`, 764 // the `guardReactiveProps` will no longer be needed 765 if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) { 766 parentCall = callPath[callPath.length - 2]; 767 } 768 } 769 if (node.type === 13 /* NodeTypes.VNODE_CALL */) { 770 if (parentCall) { 771 parentCall.arguments[0] = propsWithInjection; 772 } 773 else { 774 node.props = propsWithInjection; 775 } 776 } 777 else { 778 if (parentCall) { 779 parentCall.arguments[0] = propsWithInjection; 780 } 781 else { 782 node.arguments[2] = propsWithInjection; 783 } 784 } 785} 786// check existing key to avoid overriding user provided keys 787function hasProp(prop, props) { 788 let result = false; 789 if (prop.key.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 790 const propKeyName = prop.key.content; 791 result = props.properties.some(p => p.key.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && 792 p.key.content === propKeyName); 793 } 794 return result; 795} 796function toValidAssetId(name, type) { 797 // see issue#4422, we need adding identifier on validAssetId if variable `name` has specific character 798 return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => { 799 return searchValue === '-' ? '_' : name.charCodeAt(replaceValue).toString(); 800 })}`; 801} 802// Check if a node contains expressions that reference current context scope ids 803function hasScopeRef(node, ids) { 804 if (!node || Object.keys(ids).length === 0) { 805 return false; 806 } 807 switch (node.type) { 808 case 1 /* NodeTypes.ELEMENT */: 809 for (let i = 0; i < node.props.length; i++) { 810 const p = node.props[i]; 811 if (p.type === 7 /* NodeTypes.DIRECTIVE */ && 812 (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) { 813 return true; 814 } 815 } 816 return node.children.some(c => hasScopeRef(c, ids)); 817 case 11 /* NodeTypes.FOR */: 818 if (hasScopeRef(node.source, ids)) { 819 return true; 820 } 821 return node.children.some(c => hasScopeRef(c, ids)); 822 case 9 /* NodeTypes.IF */: 823 return node.branches.some(b => hasScopeRef(b, ids)); 824 case 10 /* NodeTypes.IF_BRANCH */: 825 if (hasScopeRef(node.condition, ids)) { 826 return true; 827 } 828 return node.children.some(c => hasScopeRef(c, ids)); 829 case 4 /* NodeTypes.SIMPLE_EXPRESSION */: 830 return (!node.isStatic && 831 isSimpleIdentifier(node.content) && 832 !!ids[node.content]); 833 case 8 /* NodeTypes.COMPOUND_EXPRESSION */: 834 return node.children.some(c => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(c) && hasScopeRef(c, ids)); 835 case 5 /* NodeTypes.INTERPOLATION */: 836 case 12 /* NodeTypes.TEXT_CALL */: 837 return hasScopeRef(node.content, ids); 838 case 2 /* NodeTypes.TEXT */: 839 case 3 /* NodeTypes.COMMENT */: 840 return false; 841 default: 842 if ((true)) ; 843 return false; 844 } 845} 846function getMemoedVNodeCall(node) { 847 if (node.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */ && node.callee === WITH_MEMO) { 848 return node.arguments[1].returns; 849 } 850 else { 851 return node; 852 } 853} 854function makeBlock(node, { helper, removeHelper, inSSR }) { 855 if (!node.isBlock) { 856 node.isBlock = true; 857 removeHelper(getVNodeHelper(inSSR, node.isComponent)); 858 helper(OPEN_BLOCK); 859 helper(getVNodeBlockHelper(inSSR, node.isComponent)); 860 } 861} 862 863const deprecationData = { 864 ["COMPILER_IS_ON_ELEMENT" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */]: { 865 message: `Platform-native elements with "is" prop will no longer be ` + 866 `treated as components in Vue 3 unless the "is" value is explicitly ` + 867 `prefixed with "vue:".`, 868 link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html` 869 }, 870 ["COMPILER_V_BIND_SYNC" /* CompilerDeprecationTypes.COMPILER_V_BIND_SYNC */]: { 871 message: key => `.sync modifier for v-bind has been removed. Use v-model with ` + 872 `argument instead. \`v-bind:${key}.sync\` should be changed to ` + 873 `\`v-model:${key}\`.`, 874 link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html` 875 }, 876 ["COMPILER_V_BIND_PROP" /* CompilerDeprecationTypes.COMPILER_V_BIND_PROP */]: { 877 message: `.prop modifier for v-bind has been removed and no longer necessary. ` + 878 `Vue 3 will automatically set a binding as DOM property when appropriate.` 879 }, 880 ["COMPILER_V_BIND_OBJECT_ORDER" /* CompilerDeprecationTypes.COMPILER_V_BIND_OBJECT_ORDER */]: { 881 message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript ` + 882 `object spread: it will now overwrite an existing non-mergeable attribute ` + 883 `that appears before v-bind in the case of conflict. ` + 884 `To retain 2.x behavior, move v-bind to make it the first attribute. ` + 885 `You can also suppress this warning if the usage is intended.`, 886 link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html` 887 }, 888 ["COMPILER_V_ON_NATIVE" /* CompilerDeprecationTypes.COMPILER_V_ON_NATIVE */]: { 889 message: `.native modifier for v-on has been removed as is no longer necessary.`, 890 link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html` 891 }, 892 ["COMPILER_V_IF_V_FOR_PRECEDENCE" /* CompilerDeprecationTypes.COMPILER_V_IF_V_FOR_PRECEDENCE */]: { 893 message: `v-if / v-for precedence when used on the same element has changed ` + 894 `in Vue 3: v-if now takes higher precedence and will no longer have ` + 895 `access to v-for scope variables. It is best to avoid the ambiguity ` + 896 `with <template> tags or use a computed property that filters v-for ` + 897 `data source.`, 898 link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html` 899 }, 900 ["COMPILER_NATIVE_TEMPLATE" /* CompilerDeprecationTypes.COMPILER_NATIVE_TEMPLATE */]: { 901 message: `<template> with no special directives will render as a native template ` + 902 `element instead of its inner content in Vue 3.` 903 }, 904 ["COMPILER_INLINE_TEMPLATE" /* CompilerDeprecationTypes.COMPILER_INLINE_TEMPLATE */]: { 905 message: `"inline-template" has been removed in Vue 3.`, 906 link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html` 907 }, 908 ["COMPILER_FILTER" /* CompilerDeprecationTypes.COMPILER_FILTERS */]: { 909 message: `filters have been removed in Vue 3. ` + 910 `The "|" symbol will be treated as native JavaScript bitwise OR operator. ` + 911 `Use method calls or computed properties instead.`, 912 link: `https://v3-migration.vuejs.org/breaking-changes/filters.html` 913 } 914}; 915function getCompatValue(key, context) { 916 const config = context.options 917 ? context.options.compatConfig 918 : context.compatConfig; 919 const value = config && config[key]; 920 if (key === 'MODE') { 921 return value || 3; // compiler defaults to v3 behavior 922 } 923 else { 924 return value; 925 } 926} 927function isCompatEnabled(key, context) { 928 const mode = getCompatValue('MODE', context); 929 const value = getCompatValue(key, context); 930 // in v3 mode, only enable if explicitly set to true 931 // otherwise enable for any non-false value 932 return mode === 3 ? value === true : value !== false; 933} 934function checkCompatEnabled(key, context, loc, ...args) { 935 const enabled = isCompatEnabled(key, context); 936 if (( true) && enabled) { 937 warnDeprecation(key, context, loc, ...args); 938 } 939 return enabled; 940} 941function warnDeprecation(key, context, loc, ...args) { 942 const val = getCompatValue(key, context); 943 if (val === 'suppress-warning') { 944 return; 945 } 946 const { message, link } = deprecationData[key]; 947 const msg = `(deprecation ${key}) ${typeof message === 'function' ? message(...args) : message}${link ? `\n Details: ${link}` : ``}`; 948 const err = new SyntaxError(msg); 949 err.code = key; 950 if (loc) 951 err.loc = loc; 952 context.onWarn(err); 953} 954 955// The default decoder only provides escapes for characters reserved as part of 956// the template syntax, and is only used if the custom renderer did not provide 957// a platform-specific decoder. 958const decodeRE = /&(gt|lt|amp|apos|quot);/g; 959const decodeMap = { 960 gt: '>', 961 lt: '<', 962 amp: '&', 963 apos: "'", 964 quot: '"' 965}; 966const defaultParserOptions = { 967 delimiters: [`{{`, `}}`], 968 getNamespace: () => 0 /* Namespaces.HTML */, 969 getTextMode: () => 0 /* TextModes.DATA */, 970 isVoidTag: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NO, 971 isPreTag: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NO, 972 isCustomElement: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NO, 973 decodeEntities: (rawText) => rawText.replace(decodeRE, (_, p1) => decodeMap[p1]), 974 onError: defaultOnError, 975 onWarn: defaultOnWarn, 976 comments: ("development" !== 'production') 977}; 978function baseParse(content, options = {}) { 979 const context = createParserContext(content, options); 980 const start = getCursor(context); 981 return createRoot(parseChildren(context, 0 /* TextModes.DATA */, []), getSelection(context, start)); 982} 983function createParserContext(content, rawOptions) { 984 const options = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, defaultParserOptions); 985 let key; 986 for (key in rawOptions) { 987 // @ts-ignore 988 options[key] = 989 rawOptions[key] === undefined 990 ? defaultParserOptions[key] 991 : rawOptions[key]; 992 } 993 return { 994 options, 995 column: 1, 996 line: 1, 997 offset: 0, 998 originalSource: content, 999 source: content, 1000 inPre: false, 1001 inVPre: false, 1002 onWarn: options.onWarn 1003 }; 1004} 1005function parseChildren(context, mode, ancestors) { 1006 const parent = last(ancestors); 1007 const ns = parent ? parent.ns : 0 /* Namespaces.HTML */; 1008 const nodes = []; 1009 while (!isEnd(context, mode, ancestors)) { 1010 const s = context.source; 1011 let node = undefined; 1012 if (mode === 0 /* TextModes.DATA */ || mode === 1 /* TextModes.RCDATA */) { 1013 if (!context.inVPre && startsWith(s, context.options.delimiters[0])) { 1014 // '{{' 1015 node = parseInterpolation(context, mode); 1016 } 1017 else if (mode === 0 /* TextModes.DATA */ && s[0] === '<') { 1018 // https://html.spec.whatwg.org/multipage/parsing.html#tag-open-state 1019 if (s.length === 1) { 1020 emitError(context, 5 /* ErrorCodes.EOF_BEFORE_TAG_NAME */, 1); 1021 } 1022 else if (s[1] === '!') { 1023 // https://html.spec.whatwg.org/multipage/parsing.html#markup-declaration-open-state 1024 if (startsWith(s, '<!--')) { 1025 node = parseComment(context); 1026 } 1027 else if (startsWith(s, '<!DOCTYPE')) { 1028 // Ignore DOCTYPE by a limitation. 1029 node = parseBogusComment(context); 1030 } 1031 else if (startsWith(s, '<![CDATA[')) { 1032 if (ns !== 0 /* Namespaces.HTML */) { 1033 node = parseCDATA(context, ancestors); 1034 } 1035 else { 1036 emitError(context, 1 /* ErrorCodes.CDATA_IN_HTML_CONTENT */); 1037 node = parseBogusComment(context); 1038 } 1039 } 1040 else { 1041 emitError(context, 11 /* ErrorCodes.INCORRECTLY_OPENED_COMMENT */); 1042 node = parseBogusComment(context); 1043 } 1044 } 1045 else if (s[1] === '/') { 1046 // https://html.spec.whatwg.org/multipage/parsing.html#end-tag-open-state 1047 if (s.length === 2) { 1048 emitError(context, 5 /* ErrorCodes.EOF_BEFORE_TAG_NAME */, 2); 1049 } 1050 else if (s[2] === '>') { 1051 emitError(context, 14 /* ErrorCodes.MISSING_END_TAG_NAME */, 2); 1052 advanceBy(context, 3); 1053 continue; 1054 } 1055 else if (/[a-z]/i.test(s[2])) { 1056 emitError(context, 23 /* ErrorCodes.X_INVALID_END_TAG */); 1057 parseTag(context, 1 /* TagType.End */, parent); 1058 continue; 1059 } 1060 else { 1061 emitError(context, 12 /* ErrorCodes.INVALID_FIRST_CHARACTER_OF_TAG_NAME */, 2); 1062 node = parseBogusComment(context); 1063 } 1064 } 1065 else if (/[a-z]/i.test(s[1])) { 1066 node = parseElement(context, ancestors); 1067 // 2.x <template> with no directive compat 1068 if (isCompatEnabled("COMPILER_NATIVE_TEMPLATE" /* CompilerDeprecationTypes.COMPILER_NATIVE_TEMPLATE */, context) && 1069 node && 1070 node.tag === 'template' && 1071 !node.props.some(p => p.type === 7 /* NodeTypes.DIRECTIVE */ && 1072 isSpecialTemplateDirective(p.name))) { 1073 ( true) && 1074 warnDeprecation("COMPILER_NATIVE_TEMPLATE" /* CompilerDeprecationTypes.COMPILER_NATIVE_TEMPLATE */, context, node.loc); 1075 node = node.children; 1076 } 1077 } 1078 else if (s[1] === '?') { 1079 emitError(context, 21 /* ErrorCodes.UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME */, 1); 1080 node = parseBogusComment(context); 1081 } 1082 else { 1083 emitError(context, 12 /* ErrorCodes.INVALID_FIRST_CHARACTER_OF_TAG_NAME */, 1); 1084 } 1085 } 1086 } 1087 if (!node) { 1088 node = parseText(context, mode); 1089 } 1090 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(node)) { 1091 for (let i = 0; i < node.length; i++) { 1092 pushNode(nodes, node[i]); 1093 } 1094 } 1095 else { 1096 pushNode(nodes, node); 1097 } 1098 } 1099 // Whitespace handling strategy like v2 1100 let removedWhitespace = false; 1101 if (mode !== 2 /* TextModes.RAWTEXT */ && mode !== 1 /* TextModes.RCDATA */) { 1102 const shouldCondense = context.options.whitespace !== 'preserve'; 1103 for (let i = 0; i < nodes.length; i++) { 1104 const node = nodes[i]; 1105 if (node.type === 2 /* NodeTypes.TEXT */) { 1106 if (!context.inPre) { 1107 if (!/[^\t\r\n\f ]/.test(node.content)) { 1108 const prev = nodes[i - 1]; 1109 const next = nodes[i + 1]; 1110 // Remove if: 1111 // - the whitespace is the first or last node, or: 1112 // - (condense mode) the whitespace is between twos comments, or: 1113 // - (condense mode) the whitespace is between comment and element, or: 1114 // - (condense mode) the whitespace is between two elements AND contains newline 1115 if (!prev || 1116 !next || 1117 (shouldCondense && 1118 ((prev.type === 3 /* NodeTypes.COMMENT */ && 1119 next.type === 3 /* NodeTypes.COMMENT */) || 1120 (prev.type === 3 /* NodeTypes.COMMENT */ && 1121 next.type === 1 /* NodeTypes.ELEMENT */) || 1122 (prev.type === 1 /* NodeTypes.ELEMENT */ && 1123 next.type === 3 /* NodeTypes.COMMENT */) || 1124 (prev.type === 1 /* NodeTypes.ELEMENT */ && 1125 next.type === 1 /* NodeTypes.ELEMENT */ && 1126 /[\r\n]/.test(node.content))))) { 1127 removedWhitespace = true; 1128 nodes[i] = null; 1129 } 1130 else { 1131 // Otherwise, the whitespace is condensed into a single space 1132 node.content = ' '; 1133 } 1134 } 1135 else if (shouldCondense) { 1136 // in condense mode, consecutive whitespaces in text are condensed 1137 // down to a single space. 1138 node.content = node.content.replace(/[\t\r\n\f ]+/g, ' '); 1139 } 1140 } 1141 else { 1142 // #6410 normalize windows newlines in <pre>: 1143 // in SSR, browsers normalize server-rendered \r\n into a single \n 1144 // in the DOM 1145 node.content = node.content.replace(/\r\n/g, '\n'); 1146 } 1147 } 1148 // Remove comment nodes if desired by configuration. 1149 else if (node.type === 3 /* NodeTypes.COMMENT */ && !context.options.comments) { 1150 removedWhitespace = true; 1151 nodes[i] = null; 1152 } 1153 } 1154 if (context.inPre && parent && context.options.isPreTag(parent.tag)) { 1155 // remove leading newline per html spec 1156 // https://html.spec.whatwg.org/multipage/grouping-content.html#the-pre-element 1157 const first = nodes[0]; 1158 if (first && first.type === 2 /* NodeTypes.TEXT */) { 1159 first.content = first.content.replace(/^\r?\n/, ''); 1160 } 1161 } 1162 } 1163 return removedWhitespace ? nodes.filter(Boolean) : nodes; 1164} 1165function pushNode(nodes, node) { 1166 if (node.type === 2 /* NodeTypes.TEXT */) { 1167 const prev = last(nodes); 1168 // Merge if both this and the previous node are text and those are 1169 // consecutive. This happens for cases like "a < b". 1170 if (prev && 1171 prev.type === 2 /* NodeTypes.TEXT */ && 1172 prev.loc.end.offset === node.loc.start.offset) { 1173 prev.content += node.content; 1174 prev.loc.end = node.loc.end; 1175 prev.loc.source += node.loc.source; 1176 return; 1177 } 1178 } 1179 nodes.push(node); 1180} 1181function parseCDATA(context, ancestors) { 1182 advanceBy(context, 9); 1183 const nodes = parseChildren(context, 3 /* TextModes.CDATA */, ancestors); 1184 if (context.source.length === 0) { 1185 emitError(context, 6 /* ErrorCodes.EOF_IN_CDATA */); 1186 } 1187 else { 1188 advanceBy(context, 3); 1189 } 1190 return nodes; 1191} 1192function parseComment(context) { 1193 const start = getCursor(context); 1194 let content; 1195 // Regular comment. 1196 const match = /--(\!)?>/.exec(context.source); 1197 if (!match) { 1198 content = context.source.slice(4); 1199 advanceBy(context, context.source.length); 1200 emitError(context, 7 /* ErrorCodes.EOF_IN_COMMENT */); 1201 } 1202 else { 1203 if (match.index <= 3) { 1204 emitError(context, 0 /* ErrorCodes.ABRUPT_CLOSING_OF_EMPTY_COMMENT */); 1205 } 1206 if (match[1]) { 1207 emitError(context, 10 /* ErrorCodes.INCORRECTLY_CLOSED_COMMENT */); 1208 } 1209 content = context.source.slice(4, match.index); 1210 // Advancing with reporting nested comments. 1211 const s = context.source.slice(0, match.index); 1212 let prevIndex = 1, nestedIndex = 0; 1213 while ((nestedIndex = s.indexOf('<!--', prevIndex)) !== -1) { 1214 advanceBy(context, nestedIndex - prevIndex + 1); 1215 if (nestedIndex + 4 < s.length) { 1216 emitError(context, 16 /* ErrorCodes.NESTED_COMMENT */); 1217 } 1218 prevIndex = nestedIndex + 1; 1219 } 1220 advanceBy(context, match.index + match[0].length - prevIndex + 1); 1221 } 1222 return { 1223 type: 3 /* NodeTypes.COMMENT */, 1224 content, 1225 loc: getSelection(context, start) 1226 }; 1227} 1228function parseBogusComment(context) { 1229 const start = getCursor(context); 1230 const contentStart = context.source[1] === '?' ? 1 : 2; 1231 let content; 1232 const closeIndex = context.source.indexOf('>'); 1233 if (closeIndex === -1) { 1234 content = context.source.slice(contentStart); 1235 advanceBy(context, context.source.length); 1236 } 1237 else { 1238 content = context.source.slice(contentStart, closeIndex); 1239 advanceBy(context, closeIndex + 1); 1240 } 1241 return { 1242 type: 3 /* NodeTypes.COMMENT */, 1243 content, 1244 loc: getSelection(context, start) 1245 }; 1246} 1247function parseElement(context, ancestors) { 1248 // Start tag. 1249 const wasInPre = context.inPre; 1250 const wasInVPre = context.inVPre; 1251 const parent = last(ancestors); 1252 const element = parseTag(context, 0 /* TagType.Start */, parent); 1253 const isPreBoundary = context.inPre && !wasInPre; 1254 const isVPreBoundary = context.inVPre && !wasInVPre; 1255 if (element.isSelfClosing || context.options.isVoidTag(element.tag)) { 1256 // #4030 self-closing <pre> tag 1257 if (isPreBoundary) { 1258 context.inPre = false; 1259 } 1260 if (isVPreBoundary) { 1261 context.inVPre = false; 1262 } 1263 return element; 1264 } 1265 // Children. 1266 ancestors.push(element); 1267 const mode = context.options.getTextMode(element, parent); 1268 const children = parseChildren(context, mode, ancestors); 1269 ancestors.pop(); 1270 // 2.x inline-template compat 1271 { 1272 const inlineTemplateProp = element.props.find(p => p.type === 6 /* NodeTypes.ATTRIBUTE */ && p.name === 'inline-template'); 1273 if (inlineTemplateProp && 1274 checkCompatEnabled("COMPILER_INLINE_TEMPLATE" /* CompilerDeprecationTypes.COMPILER_INLINE_TEMPLATE */, context, inlineTemplateProp.loc)) { 1275 const loc = getSelection(context, element.loc.end); 1276 inlineTemplateProp.value = { 1277 type: 2 /* NodeTypes.TEXT */, 1278 content: loc.source, 1279 loc 1280 }; 1281 } 1282 } 1283 element.children = children; 1284 // End tag. 1285 if (startsWithEndTagOpen(context.source, element.tag)) { 1286 parseTag(context, 1 /* TagType.End */, parent); 1287 } 1288 else { 1289 emitError(context, 24 /* ErrorCodes.X_MISSING_END_TAG */, 0, element.loc.start); 1290 if (context.source.length === 0 && element.tag.toLowerCase() === 'script') { 1291 const first = children[0]; 1292 if (first && startsWith(first.loc.source, '<!--')) { 1293 emitError(context, 8 /* ErrorCodes.EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT */); 1294 } 1295 } 1296 } 1297 element.loc = getSelection(context, element.loc.start); 1298 if (isPreBoundary) { 1299 context.inPre = false; 1300 } 1301 if (isVPreBoundary) { 1302 context.inVPre = false; 1303 } 1304 return element; 1305} 1306const isSpecialTemplateDirective = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.makeMap)(`if,else,else-if,for,slot`); 1307function parseTag(context, type, parent) { 1308 // Tag open. 1309 const start = getCursor(context); 1310 const match = /^<\/?([a-z][^\t\r\n\f />]*)/i.exec(context.source); 1311 const tag = match[1]; 1312 const ns = context.options.getNamespace(tag, parent); 1313 advanceBy(context, match[0].length); 1314 advanceSpaces(context); 1315 // save current state in case we need to re-parse attributes with v-pre 1316 const cursor = getCursor(context); 1317 const currentSource = context.source; 1318 // check <pre> tag 1319 if (context.options.isPreTag(tag)) { 1320 context.inPre = true; 1321 } 1322 // Attributes. 1323 let props = parseAttributes(context, type); 1324 // check v-pre 1325 if (type === 0 /* TagType.Start */ && 1326 !context.inVPre && 1327 props.some(p => p.type === 7 /* NodeTypes.DIRECTIVE */ && p.name === 'pre')) { 1328 context.inVPre = true; 1329 // reset context 1330 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)(context, cursor); 1331 context.source = currentSource; 1332 // re-parse attrs and filter out v-pre itself 1333 props = parseAttributes(context, type).filter(p => p.name !== 'v-pre'); 1334 } 1335 // Tag close. 1336 let isSelfClosing = false; 1337 if (context.source.length === 0) { 1338 emitError(context, 9 /* ErrorCodes.EOF_IN_TAG */); 1339 } 1340 else { 1341 isSelfClosing = startsWith(context.source, '/>'); 1342 if (type === 1 /* TagType.End */ && isSelfClosing) { 1343 emitError(context, 4 /* ErrorCodes.END_TAG_WITH_TRAILING_SOLIDUS */); 1344 } 1345 advanceBy(context, isSelfClosing ? 2 : 1); 1346 } 1347 if (type === 1 /* TagType.End */) { 1348 return; 1349 } 1350 // 2.x deprecation checks 1351 if (( true) && 1352 isCompatEnabled("COMPILER_V_IF_V_FOR_PRECEDENCE" /* CompilerDeprecationTypes.COMPILER_V_IF_V_FOR_PRECEDENCE */, context)) { 1353 let hasIf = false; 1354 let hasFor = false; 1355 for (let i = 0; i < props.length; i++) { 1356 const p = props[i]; 1357 if (p.type === 7 /* NodeTypes.DIRECTIVE */) { 1358 if (p.name === 'if') { 1359 hasIf = true; 1360 } 1361 else if (p.name === 'for') { 1362 hasFor = true; 1363 } 1364 } 1365 if (hasIf && hasFor) { 1366 warnDeprecation("COMPILER_V_IF_V_FOR_PRECEDENCE" /* CompilerDeprecationTypes.COMPILER_V_IF_V_FOR_PRECEDENCE */, context, getSelection(context, start)); 1367 break; 1368 } 1369 } 1370 } 1371 let tagType = 0 /* ElementTypes.ELEMENT */; 1372 if (!context.inVPre) { 1373 if (tag === 'slot') { 1374 tagType = 2 /* ElementTypes.SLOT */; 1375 } 1376 else if (tag === 'template') { 1377 if (props.some(p => p.type === 7 /* NodeTypes.DIRECTIVE */ && isSpecialTemplateDirective(p.name))) { 1378 tagType = 3 /* ElementTypes.TEMPLATE */; 1379 } 1380 } 1381 else if (isComponent(tag, props, context)) { 1382 tagType = 1 /* ElementTypes.COMPONENT */; 1383 } 1384 } 1385 return { 1386 type: 1 /* NodeTypes.ELEMENT */, 1387 ns, 1388 tag, 1389 tagType, 1390 props, 1391 isSelfClosing, 1392 children: [], 1393 loc: getSelection(context, start), 1394 codegenNode: undefined // to be created during transform phase 1395 }; 1396} 1397function isComponent(tag, props, context) { 1398 const options = context.options; 1399 if (options.isCustomElement(tag)) { 1400 return false; 1401 } 1402 if (tag === 'component' || 1403 /^[A-Z]/.test(tag) || 1404 isCoreComponent(tag) || 1405 (options.isBuiltInComponent && options.isBuiltInComponent(tag)) || 1406 (options.isNativeTag && !options.isNativeTag(tag))) { 1407 return true; 1408 } 1409 // at this point the tag should be a native tag, but check for potential "is" 1410 // casting 1411 for (let i = 0; i < props.length; i++) { 1412 const p = props[i]; 1413 if (p.type === 6 /* NodeTypes.ATTRIBUTE */) { 1414 if (p.name === 'is' && p.value) { 1415 if (p.value.content.startsWith('vue:')) { 1416 return true; 1417 } 1418 else if (checkCompatEnabled("COMPILER_IS_ON_ELEMENT" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */, context, p.loc)) { 1419 return true; 1420 } 1421 } 1422 } 1423 else { 1424 // directive 1425 // v-is (TODO Deprecate) 1426 if (p.name === 'is') { 1427 return true; 1428 } 1429 else if ( 1430 // :is on plain element - only treat as component in compat mode 1431 p.name === 'bind' && 1432 isStaticArgOf(p.arg, 'is') && 1433 true && 1434 checkCompatEnabled("COMPILER_IS_ON_ELEMENT" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */, context, p.loc)) { 1435 return true; 1436 } 1437 } 1438 } 1439} 1440function parseAttributes(context, type) { 1441 const props = []; 1442 const attributeNames = new Set(); 1443 while (context.source.length > 0 && 1444 !startsWith(context.source, '>') && 1445 !startsWith(context.source, '/>')) { 1446 if (startsWith(context.source, '/')) { 1447 emitError(context, 22 /* ErrorCodes.UNEXPECTED_SOLIDUS_IN_TAG */); 1448 advanceBy(context, 1); 1449 advanceSpaces(context); 1450 continue; 1451 } 1452 if (type === 1 /* TagType.End */) { 1453 emitError(context, 3 /* ErrorCodes.END_TAG_WITH_ATTRIBUTES */); 1454 } 1455 const attr = parseAttribute(context, attributeNames); 1456 // Trim whitespace between class 1457 // https://github.com/vuejs/core/issues/4251 1458 if (attr.type === 6 /* NodeTypes.ATTRIBUTE */ && 1459 attr.value && 1460 attr.name === 'class') { 1461 attr.value.content = attr.value.content.replace(/\s+/g, ' ').trim(); 1462 } 1463 if (type === 0 /* TagType.Start */) { 1464 props.push(attr); 1465 } 1466 if (/^[^\t\r\n\f />]/.test(context.source)) { 1467 emitError(context, 15 /* ErrorCodes.MISSING_WHITESPACE_BETWEEN_ATTRIBUTES */); 1468 } 1469 advanceSpaces(context); 1470 } 1471 return props; 1472} 1473function parseAttribute(context, nameSet) { 1474 // Name. 1475 const start = getCursor(context); 1476 const match = /^[^\t\r\n\f />][^\t\r\n\f />=]*/.exec(context.source); 1477 const name = match[0]; 1478 if (nameSet.has(name)) { 1479 emitError(context, 2 /* ErrorCodes.DUPLICATE_ATTRIBUTE */); 1480 } 1481 nameSet.add(name); 1482 if (name[0] === '=') { 1483 emitError(context, 19 /* ErrorCodes.UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME */); 1484 } 1485 { 1486 const pattern = /["'<]/g; 1487 let m; 1488 while ((m = pattern.exec(name))) { 1489 emitError(context, 17 /* ErrorCodes.UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME */, m.index); 1490 } 1491 } 1492 advanceBy(context, name.length); 1493 // Value 1494 let value = undefined; 1495 if (/^[\t\r\n\f ]*=/.test(context.source)) { 1496 advanceSpaces(context); 1497 advanceBy(context, 1); 1498 advanceSpaces(context); 1499 value = parseAttributeValue(context); 1500 if (!value) { 1501 emitError(context, 13 /* ErrorCodes.MISSING_ATTRIBUTE_VALUE */); 1502 } 1503 } 1504 const loc = getSelection(context, start); 1505 if (!context.inVPre && /^(v-[A-Za-z0-9-]|:|\.|@|#)/.test(name)) { 1506 const match = /(?:^v-([a-z0-9-]+))?(?:(?::|^\.|^@|^#)(\[[^\]]+\]|[^\.]+))?(.+)?$/i.exec(name); 1507 let isPropShorthand = startsWith(name, '.'); 1508 let dirName = match[1] || 1509 (isPropShorthand || startsWith(name, ':') 1510 ? 'bind' 1511 : startsWith(name, '@') 1512 ? 'on' 1513 : 'slot'); 1514 let arg; 1515 if (match[2]) { 1516 const isSlot = dirName === 'slot'; 1517 const startOffset = name.lastIndexOf(match[2]); 1518 const loc = getSelection(context, getNewPosition(context, start, startOffset), getNewPosition(context, start, startOffset + match[2].length + ((isSlot && match[3]) || '').length)); 1519 let content = match[2]; 1520 let isStatic = true; 1521 if (content.startsWith('[')) { 1522 isStatic = false; 1523 if (!content.endsWith(']')) { 1524 emitError(context, 27 /* ErrorCodes.X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END */); 1525 content = content.slice(1); 1526 } 1527 else { 1528 content = content.slice(1, content.length - 1); 1529 } 1530 } 1531 else if (isSlot) { 1532 // #1241 special case for v-slot: vuetify relies extensively on slot 1533 // names containing dots. v-slot doesn't have any modifiers and Vue 2.x 1534 // supports such usage so we are keeping it consistent with 2.x. 1535 content += match[3] || ''; 1536 } 1537 arg = { 1538 type: 4 /* NodeTypes.SIMPLE_EXPRESSION */, 1539 content, 1540 isStatic, 1541 constType: isStatic 1542 ? 3 /* ConstantTypes.CAN_STRINGIFY */ 1543 : 0 /* ConstantTypes.NOT_CONSTANT */, 1544 loc 1545 }; 1546 } 1547 if (value && value.isQuoted) { 1548 const valueLoc = value.loc; 1549 valueLoc.start.offset++; 1550 valueLoc.start.column++; 1551 valueLoc.end = advancePositionWithClone(valueLoc.start, value.content); 1552 valueLoc.source = valueLoc.source.slice(1, -1); 1553 } 1554 const modifiers = match[3] ? match[3].slice(1).split('.') : []; 1555 if (isPropShorthand) 1556 modifiers.push('prop'); 1557 // 2.x compat v-bind:foo.sync -> v-model:foo 1558 if (dirName === 'bind' && arg) { 1559 if (modifiers.includes('sync') && 1560 checkCompatEnabled("COMPILER_V_BIND_SYNC" /* CompilerDeprecationTypes.COMPILER_V_BIND_SYNC */, context, loc, arg.loc.source)) { 1561 dirName = 'model'; 1562 modifiers.splice(modifiers.indexOf('sync'), 1); 1563 } 1564 if (( true) && modifiers.includes('prop')) { 1565 checkCompatEnabled("COMPILER_V_BIND_PROP" /* CompilerDeprecationTypes.COMPILER_V_BIND_PROP */, context, loc); 1566 } 1567 } 1568 return { 1569 type: 7 /* NodeTypes.DIRECTIVE */, 1570 name: dirName, 1571 exp: value && { 1572 type: 4 /* NodeTypes.SIMPLE_EXPRESSION */, 1573 content: value.content, 1574 isStatic: false, 1575 // Treat as non-constant by default. This can be potentially set to 1576 // other values by `transformExpression` to make it eligible for hoisting. 1577 constType: 0 /* ConstantTypes.NOT_CONSTANT */, 1578 loc: value.loc 1579 }, 1580 arg, 1581 modifiers, 1582 loc 1583 }; 1584 } 1585 // missing directive name or illegal directive name 1586 if (!context.inVPre && startsWith(name, 'v-')) { 1587 emitError(context, 26 /* ErrorCodes.X_MISSING_DIRECTIVE_NAME */); 1588 } 1589 return { 1590 type: 6 /* NodeTypes.ATTRIBUTE */, 1591 name, 1592 value: value && { 1593 type: 2 /* NodeTypes.TEXT */, 1594 content: value.content, 1595 loc: value.loc 1596 }, 1597 loc 1598 }; 1599} 1600function parseAttributeValue(context) { 1601 const start = getCursor(context); 1602 let content; 1603 const quote = context.source[0]; 1604 const isQuoted = quote === `"` || quote === `'`; 1605 if (isQuoted) { 1606 // Quoted value. 1607 advanceBy(context, 1); 1608 const endIndex = context.source.indexOf(quote); 1609 if (endIndex === -1) { 1610 content = parseTextData(context, context.source.length, 4 /* TextModes.ATTRIBUTE_VALUE */); 1611 } 1612 else { 1613 content = parseTextData(context, endIndex, 4 /* TextModes.ATTRIBUTE_VALUE */); 1614 advanceBy(context, 1); 1615 } 1616 } 1617 else { 1618 // Unquoted 1619 const match = /^[^\t\r\n\f >]+/.exec(context.source); 1620 if (!match) { 1621 return undefined; 1622 } 1623 const unexpectedChars = /["'<=`]/g; 1624 let m; 1625 while ((m = unexpectedChars.exec(match[0]))) { 1626 emitError(context, 18 /* ErrorCodes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE */, m.index); 1627 } 1628 content = parseTextData(context, match[0].length, 4 /* TextModes.ATTRIBUTE_VALUE */); 1629 } 1630 return { content, isQuoted, loc: getSelection(context, start) }; 1631} 1632function parseInterpolation(context, mode) { 1633 const [open, close] = context.options.delimiters; 1634 const closeIndex = context.source.indexOf(close, open.length); 1635 if (closeIndex === -1) { 1636 emitError(context, 25 /* ErrorCodes.X_MISSING_INTERPOLATION_END */); 1637 return undefined; 1638 } 1639 const start = getCursor(context); 1640 advanceBy(context, open.length); 1641 const innerStart = getCursor(context); 1642 const innerEnd = getCursor(context); 1643 const rawContentLength = closeIndex - open.length; 1644 const rawContent = context.source.slice(0, rawContentLength); 1645 const preTrimContent = parseTextData(context, rawContentLength, mode); 1646 const content = preTrimContent.trim(); 1647 const startOffset = preTrimContent.indexOf(content); 1648 if (startOffset > 0) { 1649 advancePositionWithMutation(innerStart, rawContent, startOffset); 1650 } 1651 const endOffset = rawContentLength - (preTrimContent.length - content.length - startOffset); 1652 advancePositionWithMutation(innerEnd, rawContent, endOffset); 1653 advanceBy(context, close.length); 1654 return { 1655 type: 5 /* NodeTypes.INTERPOLATION */, 1656 content: { 1657 type: 4 /* NodeTypes.SIMPLE_EXPRESSION */, 1658 isStatic: false, 1659 // Set `isConstant` to false by default and will decide in transformExpression 1660 constType: 0 /* ConstantTypes.NOT_CONSTANT */, 1661 content, 1662 loc: getSelection(context, innerStart, innerEnd) 1663 }, 1664 loc: getSelection(context, start) 1665 }; 1666} 1667function parseText(context, mode) { 1668 const endTokens = mode === 3 /* TextModes.CDATA */ ? [']]>'] : ['<', context.options.delimiters[0]]; 1669 let endIndex = context.source.length; 1670 for (let i = 0; i < endTokens.length; i++) { 1671 const index = context.source.indexOf(endTokens[i], 1); 1672 if (index !== -1 && endIndex > index) { 1673 endIndex = index; 1674 } 1675 } 1676 const start = getCursor(context); 1677 const content = parseTextData(context, endIndex, mode); 1678 return { 1679 type: 2 /* NodeTypes.TEXT */, 1680 content, 1681 loc: getSelection(context, start) 1682 }; 1683} 1684/** 1685 * Get text data with a given length from the current location. 1686 * This translates HTML entities in the text data. 1687 */ 1688function parseTextData(context, length, mode) { 1689 const rawText = context.source.slice(0, length); 1690 advanceBy(context, length); 1691 if (mode === 2 /* TextModes.RAWTEXT */ || 1692 mode === 3 /* TextModes.CDATA */ || 1693 !rawText.includes('&')) { 1694 return rawText; 1695 } 1696 else { 1697 // DATA or RCDATA containing "&"". Entity decoding required. 1698 return context.options.decodeEntities(rawText, mode === 4 /* TextModes.ATTRIBUTE_VALUE */); 1699 } 1700} 1701function getCursor(context) { 1702 const { column, line, offset } = context; 1703 return { column, line, offset }; 1704} 1705function getSelection(context, start, end) { 1706 end = end || getCursor(context); 1707 return { 1708 start, 1709 end, 1710 source: context.originalSource.slice(start.offset, end.offset) 1711 }; 1712} 1713function last(xs) { 1714 return xs[xs.length - 1]; 1715} 1716function startsWith(source, searchString) { 1717 return source.startsWith(searchString); 1718} 1719function advanceBy(context, numberOfCharacters) { 1720 const { source } = context; 1721 advancePositionWithMutation(context, source, numberOfCharacters); 1722 context.source = source.slice(numberOfCharacters); 1723} 1724function advanceSpaces(context) { 1725 const match = /^[\t\r\n\f ]+/.exec(context.source); 1726 if (match) { 1727 advanceBy(context, match[0].length); 1728 } 1729} 1730function getNewPosition(context, start, numberOfCharacters) { 1731 return advancePositionWithClone(start, context.originalSource.slice(start.offset, numberOfCharacters), numberOfCharacters); 1732} 1733function emitError(context, code, offset, loc = getCursor(context)) { 1734 if (offset) { 1735 loc.offset += offset; 1736 loc.column += offset; 1737 } 1738 context.options.onError(createCompilerError(code, { 1739 start: loc, 1740 end: loc, 1741 source: '' 1742 })); 1743} 1744function isEnd(context, mode, ancestors) { 1745 const s = context.source; 1746 switch (mode) { 1747 case 0 /* TextModes.DATA */: 1748 if (startsWith(s, '</')) { 1749 // TODO: probably bad performance 1750 for (let i = ancestors.length - 1; i >= 0; --i) { 1751 if (startsWithEndTagOpen(s, ancestors[i].tag)) { 1752 return true; 1753 } 1754 } 1755 } 1756 break; 1757 case 1 /* TextModes.RCDATA */: 1758 case 2 /* TextModes.RAWTEXT */: { 1759 const parent = last(ancestors); 1760 if (parent && startsWithEndTagOpen(s, parent.tag)) { 1761 return true; 1762 } 1763 break; 1764 } 1765 case 3 /* TextModes.CDATA */: 1766 if (startsWith(s, ']]>')) { 1767 return true; 1768 } 1769 break; 1770 } 1771 return !s; 1772} 1773function startsWithEndTagOpen(source, tag) { 1774 return (startsWith(source, '</') && 1775 source.slice(2, 2 + tag.length).toLowerCase() === tag.toLowerCase() && 1776 /[\t\r\n\f />]/.test(source[2 + tag.length] || '>')); 1777} 1778 1779function hoistStatic(root, context) { 1780 walk(root, context, 1781 // Root node is unfortunately non-hoistable due to potential parent 1782 // fallthrough attributes. 1783 isSingleElementRoot(root, root.children[0])); 1784} 1785function isSingleElementRoot(root, child) { 1786 const { children } = root; 1787 return (children.length === 1 && 1788 child.type === 1 /* NodeTypes.ELEMENT */ && 1789 !isSlotOutlet(child)); 1790} 1791function walk(node, context, doNotHoistNode = false) { 1792 const { children } = node; 1793 const originalCount = children.length; 1794 let hoistedCount = 0; 1795 for (let i = 0; i < children.length; i++) { 1796 const child = children[i]; 1797 // only plain elements & text calls are eligible for hoisting. 1798 if (child.type === 1 /* NodeTypes.ELEMENT */ && 1799 child.tagType === 0 /* ElementTypes.ELEMENT */) { 1800 const constantType = doNotHoistNode 1801 ? 0 /* ConstantTypes.NOT_CONSTANT */ 1802 : getConstantType(child, context); 1803 if (constantType > 0 /* ConstantTypes.NOT_CONSTANT */) { 1804 if (constantType >= 2 /* ConstantTypes.CAN_HOIST */) { 1805 child.codegenNode.patchFlag = 1806 -1 /* PatchFlags.HOISTED */ + (( true) ? ` /* HOISTED */` : 0); 1807 child.codegenNode = context.hoist(child.codegenNode); 1808 hoistedCount++; 1809 continue; 1810 } 1811 } 1812 else { 1813 // node may contain dynamic children, but its props may be eligible for 1814 // hoisting. 1815 const codegenNode = child.codegenNode; 1816 if (codegenNode.type === 13 /* NodeTypes.VNODE_CALL */) { 1817 const flag = getPatchFlag(codegenNode); 1818 if ((!flag || 1819 flag === 512 /* PatchFlags.NEED_PATCH */ || 1820 flag === 1 /* PatchFlags.TEXT */) && 1821 getGeneratedPropsConstantType(child, context) >= 1822 2 /* ConstantTypes.CAN_HOIST */) { 1823 const props = getNodeProps(child); 1824 if (props) { 1825 codegenNode.props = context.hoist(props); 1826 } 1827 } 1828 if (codegenNode.dynamicProps) { 1829 codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps); 1830 } 1831 } 1832 } 1833 } 1834 // walk further 1835 if (child.type === 1 /* NodeTypes.ELEMENT */) { 1836 const isComponent = child.tagType === 1 /* ElementTypes.COMPONENT */; 1837 if (isComponent) { 1838 context.scopes.vSlot++; 1839 } 1840 walk(child, context); 1841 if (isComponent) { 1842 context.scopes.vSlot--; 1843 } 1844 } 1845 else if (child.type === 11 /* NodeTypes.FOR */) { 1846 // Do not hoist v-for single child because it has to be a block 1847 walk(child, context, child.children.length === 1); 1848 } 1849 else if (child.type === 9 /* NodeTypes.IF */) { 1850 for (let i = 0; i < child.branches.length; i++) { 1851 // Do not hoist v-if single child because it has to be a block 1852 walk(child.branches[i], context, child.branches[i].children.length === 1); 1853 } 1854 } 1855 } 1856 if (hoistedCount && context.transformHoist) { 1857 context.transformHoist(children, context, node); 1858 } 1859 // all children were hoisted - the entire children array is hoistable. 1860 if (hoistedCount && 1861 hoistedCount === originalCount && 1862 node.type === 1 /* NodeTypes.ELEMENT */ && 1863 node.tagType === 0 /* ElementTypes.ELEMENT */ && 1864 node.codegenNode && 1865 node.codegenNode.type === 13 /* NodeTypes.VNODE_CALL */ && 1866 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(node.codegenNode.children)) { 1867 node.codegenNode.children = context.hoist(createArrayExpression(node.codegenNode.children)); 1868 } 1869} 1870function getConstantType(node, context) { 1871 const { constantCache } = context; 1872 switch (node.type) { 1873 case 1 /* NodeTypes.ELEMENT */: 1874 if (node.tagType !== 0 /* ElementTypes.ELEMENT */) { 1875 return 0 /* ConstantTypes.NOT_CONSTANT */; 1876 } 1877 const cached = constantCache.get(node); 1878 if (cached !== undefined) { 1879 return cached; 1880 } 1881 const codegenNode = node.codegenNode; 1882 if (codegenNode.type !== 13 /* NodeTypes.VNODE_CALL */) { 1883 return 0 /* ConstantTypes.NOT_CONSTANT */; 1884 } 1885 if (codegenNode.isBlock && 1886 node.tag !== 'svg' && 1887 node.tag !== 'foreignObject') { 1888 return 0 /* ConstantTypes.NOT_CONSTANT */; 1889 } 1890 const flag = getPatchFlag(codegenNode); 1891 if (!flag) { 1892 let returnType = 3 /* ConstantTypes.CAN_STRINGIFY */; 1893 // Element itself has no patch flag. However we still need to check: 1894 // 1. Even for a node with no patch flag, it is possible for it to contain 1895 // non-hoistable expressions that refers to scope variables, e.g. compiler 1896 // injected keys or cached event handlers. Therefore we need to always 1897 // check the codegenNode's props to be sure. 1898 const generatedPropsType = getGeneratedPropsConstantType(node, context); 1899 if (generatedPropsType === 0 /* ConstantTypes.NOT_CONSTANT */) { 1900 constantCache.set(node, 0 /* ConstantTypes.NOT_CONSTANT */); 1901 return 0 /* ConstantTypes.NOT_CONSTANT */; 1902 } 1903 if (generatedPropsType < returnType) { 1904 returnType = generatedPropsType; 1905 } 1906 // 2. its children. 1907 for (let i = 0; i < node.children.length; i++) { 1908 const childType = getConstantType(node.children[i], context); 1909 if (childType === 0 /* ConstantTypes.NOT_CONSTANT */) { 1910 constantCache.set(node, 0 /* ConstantTypes.NOT_CONSTANT */); 1911 return 0 /* ConstantTypes.NOT_CONSTANT */; 1912 } 1913 if (childType < returnType) { 1914 returnType = childType; 1915 } 1916 } 1917 // 3. if the type is not already CAN_SKIP_PATCH which is the lowest non-0 1918 // type, check if any of the props can cause the type to be lowered 1919 // we can skip can_patch because it's guaranteed by the absence of a 1920 // patchFlag. 1921 if (returnType > 1 /* ConstantTypes.CAN_SKIP_PATCH */) { 1922 for (let i = 0; i < node.props.length; i++) { 1923 const p = node.props[i]; 1924 if (p.type === 7 /* NodeTypes.DIRECTIVE */ && p.name === 'bind' && p.exp) { 1925 const expType = getConstantType(p.exp, context); 1926 if (expType === 0 /* ConstantTypes.NOT_CONSTANT */) { 1927 constantCache.set(node, 0 /* ConstantTypes.NOT_CONSTANT */); 1928 return 0 /* ConstantTypes.NOT_CONSTANT */; 1929 } 1930 if (expType < returnType) { 1931 returnType = expType; 1932 } 1933 } 1934 } 1935 } 1936 // only svg/foreignObject could be block here, however if they are 1937 // static then they don't need to be blocks since there will be no 1938 // nested updates. 1939 if (codegenNode.isBlock) { 1940 // except set custom directives. 1941 for (let i = 0; i < node.props.length; i++) { 1942 const p = node.props[i]; 1943 if (p.type === 7 /* NodeTypes.DIRECTIVE */) { 1944 constantCache.set(node, 0 /* ConstantTypes.NOT_CONSTANT */); 1945 return 0 /* ConstantTypes.NOT_CONSTANT */; 1946 } 1947 } 1948 context.removeHelper(OPEN_BLOCK); 1949 context.removeHelper(getVNodeBlockHelper(context.inSSR, codegenNode.isComponent)); 1950 codegenNode.isBlock = false; 1951 context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent)); 1952 } 1953 constantCache.set(node, returnType); 1954 return returnType; 1955 } 1956 else { 1957 constantCache.set(node, 0 /* ConstantTypes.NOT_CONSTANT */); 1958 return 0 /* ConstantTypes.NOT_CONSTANT */; 1959 } 1960 case 2 /* NodeTypes.TEXT */: 1961 case 3 /* NodeTypes.COMMENT */: 1962 return 3 /* ConstantTypes.CAN_STRINGIFY */; 1963 case 9 /* NodeTypes.IF */: 1964 case 11 /* NodeTypes.FOR */: 1965 case 10 /* NodeTypes.IF_BRANCH */: 1966 return 0 /* ConstantTypes.NOT_CONSTANT */; 1967 case 5 /* NodeTypes.INTERPOLATION */: 1968 case 12 /* NodeTypes.TEXT_CALL */: 1969 return getConstantType(node.content, context); 1970 case 4 /* NodeTypes.SIMPLE_EXPRESSION */: 1971 return node.constType; 1972 case 8 /* NodeTypes.COMPOUND_EXPRESSION */: 1973 let returnType = 3 /* ConstantTypes.CAN_STRINGIFY */; 1974 for (let i = 0; i < node.children.length; i++) { 1975 const child = node.children[i]; 1976 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(child) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(child)) { 1977 continue; 1978 } 1979 const childType = getConstantType(child, context); 1980 if (childType === 0 /* ConstantTypes.NOT_CONSTANT */) { 1981 return 0 /* ConstantTypes.NOT_CONSTANT */; 1982 } 1983 else if (childType < returnType) { 1984 returnType = childType; 1985 } 1986 } 1987 return returnType; 1988 default: 1989 if ((true)) ; 1990 return 0 /* ConstantTypes.NOT_CONSTANT */; 1991 } 1992} 1993const allowHoistedHelperSet = new Set([ 1994 NORMALIZE_CLASS, 1995 NORMALIZE_STYLE, 1996 NORMALIZE_PROPS, 1997 GUARD_REACTIVE_PROPS 1998]); 1999function getConstantTypeOfHelperCall(value, context) { 2000 if (value.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */ && 2001 !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(value.callee) && 2002 allowHoistedHelperSet.has(value.callee)) { 2003 const arg = value.arguments[0]; 2004 if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 2005 return getConstantType(arg, context); 2006 } 2007 else if (arg.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) { 2008 // in the case of nested helper call, e.g. `normalizeProps(guardReactiveProps(exp))` 2009 return getConstantTypeOfHelperCall(arg, context); 2010 } 2011 } 2012 return 0 /* ConstantTypes.NOT_CONSTANT */; 2013} 2014function getGeneratedPropsConstantType(node, context) { 2015 let returnType = 3 /* ConstantTypes.CAN_STRINGIFY */; 2016 const props = getNodeProps(node); 2017 if (props && props.type === 15 /* NodeTypes.JS_OBJECT_EXPRESSION */) { 2018 const { properties } = props; 2019 for (let i = 0; i < properties.length; i++) { 2020 const { key, value } = properties[i]; 2021 const keyType = getConstantType(key, context); 2022 if (keyType === 0 /* ConstantTypes.NOT_CONSTANT */) { 2023 return keyType; 2024 } 2025 if (keyType < returnType) { 2026 returnType = keyType; 2027 } 2028 let valueType; 2029 if (value.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 2030 valueType = getConstantType(value, context); 2031 } 2032 else if (value.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) { 2033 // some helper calls can be hoisted, 2034 // such as the `normalizeProps` generated by the compiler for pre-normalize class, 2035 // in this case we need to respect the ConstantType of the helper's arguments 2036 valueType = getConstantTypeOfHelperCall(value, context); 2037 } 2038 else { 2039 valueType = 0 /* ConstantTypes.NOT_CONSTANT */; 2040 } 2041 if (valueType === 0 /* ConstantTypes.NOT_CONSTANT */) { 2042 return valueType; 2043 } 2044 if (valueType < returnType) { 2045 returnType = valueType; 2046 } 2047 } 2048 } 2049 return returnType; 2050} 2051function getNodeProps(node) { 2052 const codegenNode = node.codegenNode; 2053 if (codegenNode.type === 13 /* NodeTypes.VNODE_CALL */) { 2054 return codegenNode.props; 2055 } 2056} 2057function getPatchFlag(node) { 2058 const flag = node.patchFlag; 2059 return flag ? parseInt(flag, 10) : undefined; 2060} 2061 2062function createTransformContext(root, { filename = '', prefixIdentifiers = false, hoistStatic = false, cacheHandlers = false, nodeTransforms = [], directiveTransforms = {}, transformHoist = null, isBuiltInComponent = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP, isCustomElement = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP, expressionPlugins = [], scopeId = null, slotted = true, ssr = false, inSSR = false, ssrCssVars = ``, bindingMetadata = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.EMPTY_OBJ, inline = false, isTS = false, onError = defaultOnError, onWarn = defaultOnWarn, compatConfig }) { 2063 const nameMatch = filename.replace(/\?.*$/, '').match(/([^/\\]+)\.\w+$/); 2064 const context = { 2065 // options 2066 selfName: nameMatch && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.capitalize)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(nameMatch[1])), 2067 prefixIdentifiers, 2068 hoistStatic, 2069 cacheHandlers, 2070 nodeTransforms, 2071 directiveTransforms, 2072 transformHoist, 2073 isBuiltInComponent, 2074 isCustomElement, 2075 expressionPlugins, 2076 scopeId, 2077 slotted, 2078 ssr, 2079 inSSR, 2080 ssrCssVars, 2081 bindingMetadata, 2082 inline, 2083 isTS, 2084 onError, 2085 onWarn, 2086 compatConfig, 2087 // state 2088 root, 2089 helpers: new Map(), 2090 components: new Set(), 2091 directives: new Set(), 2092 hoists: [], 2093 imports: [], 2094 constantCache: new Map(), 2095 temps: 0, 2096 cached: 0, 2097 identifiers: Object.create(null), 2098 scopes: { 2099 vFor: 0, 2100 vSlot: 0, 2101 vPre: 0, 2102 vOnce: 0 2103 }, 2104 parent: null, 2105 currentNode: root, 2106 childIndex: 0, 2107 inVOnce: false, 2108 // methods 2109 helper(name) { 2110 const count = context.helpers.get(name) || 0; 2111 context.helpers.set(name, count + 1); 2112 return name; 2113 }, 2114 removeHelper(name) { 2115 const count = context.helpers.get(name); 2116 if (count) { 2117 const currentCount = count - 1; 2118 if (!currentCount) { 2119 context.helpers.delete(name); 2120 } 2121 else { 2122 context.helpers.set(name, currentCount); 2123 } 2124 } 2125 }, 2126 helperString(name) { 2127 return `_${helperNameMap[context.helper(name)]}`; 2128 }, 2129 replaceNode(node) { 2130 /* istanbul ignore if */ 2131 if ((true)) { 2132 if (!context.currentNode) { 2133 throw new Error(`Node being replaced is already removed.`); 2134 } 2135 if (!context.parent) { 2136 throw new Error(`Cannot replace root node.`); 2137 } 2138 } 2139 context.parent.children[context.childIndex] = context.currentNode = node; 2140 }, 2141 removeNode(node) { 2142 if (( true) && !context.parent) { 2143 throw new Error(`Cannot remove root node.`); 2144 } 2145 const list = context.parent.children; 2146 const removalIndex = node 2147 ? list.indexOf(node) 2148 : context.currentNode 2149 ? context.childIndex 2150 : -1; 2151 /* istanbul ignore if */ 2152 if (( true) && removalIndex < 0) { 2153 throw new Error(`node being removed is not a child of current parent`); 2154 } 2155 if (!node || node === context.currentNode) { 2156 // current node removed 2157 context.currentNode = null; 2158 context.onNodeRemoved(); 2159 } 2160 else { 2161 // sibling node removed 2162 if (context.childIndex > removalIndex) { 2163 context.childIndex--; 2164 context.onNodeRemoved(); 2165 } 2166 } 2167 context.parent.children.splice(removalIndex, 1); 2168 }, 2169 onNodeRemoved: () => { }, 2170 addIdentifiers(exp) { 2171 }, 2172 removeIdentifiers(exp) { 2173 }, 2174 hoist(exp) { 2175 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(exp)) 2176 exp = createSimpleExpression(exp); 2177 context.hoists.push(exp); 2178 const identifier = createSimpleExpression(`_hoisted_${context.hoists.length}`, false, exp.loc, 2 /* ConstantTypes.CAN_HOIST */); 2179 identifier.hoisted = exp; 2180 return identifier; 2181 }, 2182 cache(exp, isVNode = false) { 2183 return createCacheExpression(context.cached++, exp, isVNode); 2184 } 2185 }; 2186 { 2187 context.filters = new Set(); 2188 } 2189 return context; 2190} 2191function transform(root, options) { 2192 const context = createTransformContext(root, options); 2193 traverseNode(root, context); 2194 if (options.hoistStatic) { 2195 hoistStatic(root, context); 2196 } 2197 if (!options.ssr) { 2198 createRootCodegen(root, context); 2199 } 2200 // finalize meta information 2201 root.helpers = [...context.helpers.keys()]; 2202 root.components = [...context.components]; 2203 root.directives = [...context.directives]; 2204 root.imports = context.imports; 2205 root.hoists = context.hoists; 2206 root.temps = context.temps; 2207 root.cached = context.cached; 2208 { 2209 root.filters = [...context.filters]; 2210 } 2211} 2212function createRootCodegen(root, context) { 2213 const { helper } = context; 2214 const { children } = root; 2215 if (children.length === 1) { 2216 const child = children[0]; 2217 // if the single child is an element, turn it into a block. 2218 if (isSingleElementRoot(root, child) && child.codegenNode) { 2219 // single element root is never hoisted so codegenNode will never be 2220 // SimpleExpressionNode 2221 const codegenNode = child.codegenNode; 2222 if (codegenNode.type === 13 /* NodeTypes.VNODE_CALL */) { 2223 makeBlock(codegenNode, context); 2224 } 2225 root.codegenNode = codegenNode; 2226 } 2227 else { 2228 // - single <slot/>, IfNode, ForNode: already blocks. 2229 // - single text node: always patched. 2230 // root codegen falls through via genNode() 2231 root.codegenNode = child; 2232 } 2233 } 2234 else if (children.length > 1) { 2235 // root has multiple nodes - return a fragment block. 2236 let patchFlag = 64 /* PatchFlags.STABLE_FRAGMENT */; 2237 let patchFlagText = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[64]; 2238 // check if the fragment actually contains a single valid child with 2239 // the rest being comments 2240 if (( true) && 2241 children.filter(c => c.type !== 3 /* NodeTypes.COMMENT */).length === 1) { 2242 patchFlag |= 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */; 2243 patchFlagText += `, ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[2048]}`; 2244 } 2245 root.codegenNode = createVNodeCall(context, helper(FRAGMENT), undefined, root.children, patchFlag + (( true) ? ` /* ${patchFlagText} */` : 0), undefined, undefined, true, undefined, false /* isComponent */); 2246 } 2247 else ; 2248} 2249function traverseChildren(parent, context) { 2250 let i = 0; 2251 const nodeRemoved = () => { 2252 i--; 2253 }; 2254 for (; i < parent.children.length; i++) { 2255 const child = parent.children[i]; 2256 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(child)) 2257 continue; 2258 context.parent = parent; 2259 context.childIndex = i; 2260 context.onNodeRemoved = nodeRemoved; 2261 traverseNode(child, context); 2262 } 2263} 2264function traverseNode(node, context) { 2265 context.currentNode = node; 2266 // apply transform plugins 2267 const { nodeTransforms } = context; 2268 const exitFns = []; 2269 for (let i = 0; i < nodeTransforms.length; i++) { 2270 const onExit = nodeTransforms[i](node, context); 2271 if (onExit) { 2272 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(onExit)) { 2273 exitFns.push(...onExit); 2274 } 2275 else { 2276 exitFns.push(onExit); 2277 } 2278 } 2279 if (!context.currentNode) { 2280 // node was removed 2281 return; 2282 } 2283 else { 2284 // node may have been replaced 2285 node = context.currentNode; 2286 } 2287 } 2288 switch (node.type) { 2289 case 3 /* NodeTypes.COMMENT */: 2290 if (!context.ssr) { 2291 // inject import for the Comment symbol, which is needed for creating 2292 // comment nodes with `createVNode` 2293 context.helper(CREATE_COMMENT); 2294 } 2295 break; 2296 case 5 /* NodeTypes.INTERPOLATION */: 2297 // no need to traverse, but we need to inject toString helper 2298 if (!context.ssr) { 2299 context.helper(TO_DISPLAY_STRING); 2300 } 2301 break; 2302 // for container types, further traverse downwards 2303 case 9 /* NodeTypes.IF */: 2304 for (let i = 0; i < node.branches.length; i++) { 2305 traverseNode(node.branches[i], context); 2306 } 2307 break; 2308 case 10 /* NodeTypes.IF_BRANCH */: 2309 case 11 /* NodeTypes.FOR */: 2310 case 1 /* NodeTypes.ELEMENT */: 2311 case 0 /* NodeTypes.ROOT */: 2312 traverseChildren(node, context); 2313 break; 2314 } 2315 // exit transforms 2316 context.currentNode = node; 2317 let i = exitFns.length; 2318 while (i--) { 2319 exitFns[i](); 2320 } 2321} 2322function createStructuralDirectiveTransform(name, fn) { 2323 const matches = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(name) 2324 ? (n) => n === name 2325 : (n) => name.test(n); 2326 return (node, context) => { 2327 if (node.type === 1 /* NodeTypes.ELEMENT */) { 2328 const { props } = node; 2329 // structural directive transforms are not concerned with slots 2330 // as they are handled separately in vSlot.ts 2331 if (node.tagType === 3 /* ElementTypes.TEMPLATE */ && props.some(isVSlot)) { 2332 return; 2333 } 2334 const exitFns = []; 2335 for (let i = 0; i < props.length; i++) { 2336 const prop = props[i]; 2337 if (prop.type === 7 /* NodeTypes.DIRECTIVE */ && matches(prop.name)) { 2338 // structural directives are removed to avoid infinite recursion 2339 // also we remove them *before* applying so that it can further 2340 // traverse itself in case it moves the node around 2341 props.splice(i, 1); 2342 i--; 2343 const onExit = fn(node, prop, context); 2344 if (onExit) 2345 exitFns.push(onExit); 2346 } 2347 } 2348 return exitFns; 2349 } 2350 }; 2351} 2352 2353const PURE_ANNOTATION = `/*#__PURE__*/`; 2354const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`; 2355function createCodegenContext(ast, { mode = 'function', prefixIdentifiers = mode === 'module', sourceMap = false, filename = `template.vue.html`, scopeId = null, optimizeImports = false, runtimeGlobalName = `Vue`, runtimeModuleName = `vue`, ssrRuntimeModuleName = 'vue/server-renderer', ssr = false, isTS = false, inSSR = false }) { 2356 const context = { 2357 mode, 2358 prefixIdentifiers, 2359 sourceMap, 2360 filename, 2361 scopeId, 2362 optimizeImports, 2363 runtimeGlobalName, 2364 runtimeModuleName, 2365 ssrRuntimeModuleName, 2366 ssr, 2367 isTS, 2368 inSSR, 2369 source: ast.loc.source, 2370 code: ``, 2371 column: 1, 2372 line: 1, 2373 offset: 0, 2374 indentLevel: 0, 2375 pure: false, 2376 map: undefined, 2377 helper(key) { 2378 return `_${helperNameMap[key]}`; 2379 }, 2380 push(code, node) { 2381 context.code += code; 2382 }, 2383 indent() { 2384 newline(++context.indentLevel); 2385 }, 2386 deindent(withoutNewLine = false) { 2387 if (withoutNewLine) { 2388 --context.indentLevel; 2389 } 2390 else { 2391 newline(--context.indentLevel); 2392 } 2393 }, 2394 newline() { 2395 newline(context.indentLevel); 2396 } 2397 }; 2398 function newline(n) { 2399 context.push('\n' + ` `.repeat(n)); 2400 } 2401 return context; 2402} 2403function generate(ast, options = {}) { 2404 const context = createCodegenContext(ast, options); 2405 if (options.onContextCreated) 2406 options.onContextCreated(context); 2407 const { mode, push, prefixIdentifiers, indent, deindent, newline, scopeId, ssr } = context; 2408 const hasHelpers = ast.helpers.length > 0; 2409 const useWithBlock = !prefixIdentifiers && mode !== 'module'; 2410 // preambles 2411 // in setup() inline mode, the preamble is generated in a sub context 2412 // and returned separately. 2413 const preambleContext = context; 2414 { 2415 genFunctionPreamble(ast, preambleContext); 2416 } 2417 // enter render function 2418 const functionName = ssr ? `ssrRender` : `render`; 2419 const args = ssr ? ['_ctx', '_push', '_parent', '_attrs'] : ['_ctx', '_cache']; 2420 const signature = args.join(', '); 2421 { 2422 push(`function ${functionName}(${signature}) {`); 2423 } 2424 indent(); 2425 if (useWithBlock) { 2426 push(`with (_ctx) {`); 2427 indent(); 2428 // function mode const declarations should be inside with block 2429 // also they should be renamed to avoid collision with user properties 2430 if (hasHelpers) { 2431 push(`const { ${ast.helpers.map(aliasHelper).join(', ')} } = _Vue`); 2432 push(`\n`); 2433 newline(); 2434 } 2435 } 2436 // generate asset resolution statements 2437 if (ast.components.length) { 2438 genAssets(ast.components, 'component', context); 2439 if (ast.directives.length || ast.temps > 0) { 2440 newline(); 2441 } 2442 } 2443 if (ast.directives.length) { 2444 genAssets(ast.directives, 'directive', context); 2445 if (ast.temps > 0) { 2446 newline(); 2447 } 2448 } 2449 if (ast.filters && ast.filters.length) { 2450 newline(); 2451 genAssets(ast.filters, 'filter', context); 2452 newline(); 2453 } 2454 if (ast.temps > 0) { 2455 push(`let `); 2456 for (let i = 0; i < ast.temps; i++) { 2457 push(`${i > 0 ? `, ` : ``}_temp${i}`); 2458 } 2459 } 2460 if (ast.components.length || ast.directives.length || ast.temps) { 2461 push(`\n`); 2462 newline(); 2463 } 2464 // generate the VNode tree expression 2465 if (!ssr) { 2466 push(`return `); 2467 } 2468 if (ast.codegenNode) { 2469 genNode(ast.codegenNode, context); 2470 } 2471 else { 2472 push(`null`); 2473 } 2474 if (useWithBlock) { 2475 deindent(); 2476 push(`}`); 2477 } 2478 deindent(); 2479 push(`}`); 2480 return { 2481 ast, 2482 code: context.code, 2483 preamble: ``, 2484 // SourceMapGenerator does have toJSON() method but it's not in the types 2485 map: context.map ? context.map.toJSON() : undefined 2486 }; 2487} 2488function genFunctionPreamble(ast, context) { 2489 const { ssr, prefixIdentifiers, push, newline, runtimeModuleName, runtimeGlobalName, ssrRuntimeModuleName } = context; 2490 const VueBinding = runtimeGlobalName; 2491 // Generate const declaration for helpers 2492 // In prefix mode, we place the const declaration at top so it's done 2493 // only once; But if we not prefixing, we place the declaration inside the 2494 // with block so it doesn't incur the `in` check cost for every helper access. 2495 if (ast.helpers.length > 0) { 2496 { 2497 // "with" mode. 2498 // save Vue in a separate variable to avoid collision 2499 push(`const _Vue = ${VueBinding}\n`); 2500 // in "with" mode, helpers are declared inside the with block to avoid 2501 // has check cost, but hoists are lifted out of the function - we need 2502 // to provide the helper here. 2503 if (ast.hoists.length) { 2504 const staticHelpers = [ 2505 CREATE_VNODE, 2506 CREATE_ELEMENT_VNODE, 2507 CREATE_COMMENT, 2508 CREATE_TEXT, 2509 CREATE_STATIC 2510 ] 2511 .filter(helper => ast.helpers.includes(helper)) 2512 .map(aliasHelper) 2513 .join(', '); 2514 push(`const { ${staticHelpers} } = _Vue\n`); 2515 } 2516 } 2517 } 2518 genHoists(ast.hoists, context); 2519 newline(); 2520 push(`return `); 2521} 2522function genAssets(assets, type, { helper, push, newline, isTS }) { 2523 const resolver = helper(type === 'filter' 2524 ? RESOLVE_FILTER 2525 : type === 'component' 2526 ? RESOLVE_COMPONENT 2527 : RESOLVE_DIRECTIVE); 2528 for (let i = 0; i < assets.length; i++) { 2529 let id = assets[i]; 2530 // potential component implicit self-reference inferred from SFC filename 2531 const maybeSelfReference = id.endsWith('__self'); 2532 if (maybeSelfReference) { 2533 id = id.slice(0, -6); 2534 } 2535 push(`const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`); 2536 if (i < assets.length - 1) { 2537 newline(); 2538 } 2539 } 2540} 2541function genHoists(hoists, context) { 2542 if (!hoists.length) { 2543 return; 2544 } 2545 context.pure = true; 2546 const { push, newline, helper, scopeId, mode } = context; 2547 newline(); 2548 for (let i = 0; i < hoists.length; i++) { 2549 const exp = hoists[i]; 2550 if (exp) { 2551 push(`const _hoisted_${i + 1} = ${``}`); 2552 genNode(exp, context); 2553 newline(); 2554 } 2555 } 2556 context.pure = false; 2557} 2558function isText$1(n) { 2559 return ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(n) || 2560 n.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ || 2561 n.type === 2 /* NodeTypes.TEXT */ || 2562 n.type === 5 /* NodeTypes.INTERPOLATION */ || 2563 n.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */); 2564} 2565function genNodeListAsArray(nodes, context) { 2566 const multilines = nodes.length > 3 || 2567 ((( true)) && nodes.some(n => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(n) || !isText$1(n))); 2568 context.push(`[`); 2569 multilines && context.indent(); 2570 genNodeList(nodes, context, multilines); 2571 multilines && context.deindent(); 2572 context.push(`]`); 2573} 2574function genNodeList(nodes, context, multilines = false, comma = true) { 2575 const { push, newline } = context; 2576 for (let i = 0; i < nodes.length; i++) { 2577 const node = nodes[i]; 2578 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(node)) { 2579 push(node); 2580 } 2581 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(node)) { 2582 genNodeListAsArray(node, context); 2583 } 2584 else { 2585 genNode(node, context); 2586 } 2587 if (i < nodes.length - 1) { 2588 if (multilines) { 2589 comma && push(','); 2590 newline(); 2591 } 2592 else { 2593 comma && push(', '); 2594 } 2595 } 2596 } 2597} 2598function genNode(node, context) { 2599 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(node)) { 2600 context.push(node); 2601 return; 2602 } 2603 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(node)) { 2604 context.push(context.helper(node)); 2605 return; 2606 } 2607 switch (node.type) { 2608 case 1 /* NodeTypes.ELEMENT */: 2609 case 9 /* NodeTypes.IF */: 2610 case 11 /* NodeTypes.FOR */: 2611 ( true) && 2612 assert(node.codegenNode != null, `Codegen node is missing for element/if/for node. ` + 2613 `Apply appropriate transforms first.`); 2614 genNode(node.codegenNode, context); 2615 break; 2616 case 2 /* NodeTypes.TEXT */: 2617 genText(node, context); 2618 break; 2619 case 4 /* NodeTypes.SIMPLE_EXPRESSION */: 2620 genExpression(node, context); 2621 break; 2622 case 5 /* NodeTypes.INTERPOLATION */: 2623 genInterpolation(node, context); 2624 break; 2625 case 12 /* NodeTypes.TEXT_CALL */: 2626 genNode(node.codegenNode, context); 2627 break; 2628 case 8 /* NodeTypes.COMPOUND_EXPRESSION */: 2629 genCompoundExpression(node, context); 2630 break; 2631 case 3 /* NodeTypes.COMMENT */: 2632 genComment(node, context); 2633 break; 2634 case 13 /* NodeTypes.VNODE_CALL */: 2635 genVNodeCall(node, context); 2636 break; 2637 case 14 /* NodeTypes.JS_CALL_EXPRESSION */: 2638 genCallExpression(node, context); 2639 break; 2640 case 15 /* NodeTypes.JS_OBJECT_EXPRESSION */: 2641 genObjectExpression(node, context); 2642 break; 2643 case 17 /* NodeTypes.JS_ARRAY_EXPRESSION */: 2644 genArrayExpression(node, context); 2645 break; 2646 case 18 /* NodeTypes.JS_FUNCTION_EXPRESSION */: 2647 genFunctionExpression(node, context); 2648 break; 2649 case 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */: 2650 genConditionalExpression(node, context); 2651 break; 2652 case 20 /* NodeTypes.JS_CACHE_EXPRESSION */: 2653 genCacheExpression(node, context); 2654 break; 2655 case 21 /* NodeTypes.JS_BLOCK_STATEMENT */: 2656 genNodeList(node.body, context, true, false); 2657 break; 2658 // SSR only types 2659 case 22 /* NodeTypes.JS_TEMPLATE_LITERAL */: 2660 break; 2661 case 23 /* NodeTypes.JS_IF_STATEMENT */: 2662 break; 2663 case 24 /* NodeTypes.JS_ASSIGNMENT_EXPRESSION */: 2664 break; 2665 case 25 /* NodeTypes.JS_SEQUENCE_EXPRESSION */: 2666 break; 2667 case 26 /* NodeTypes.JS_RETURN_STATEMENT */: 2668 break; 2669 /* istanbul ignore next */ 2670 case 10 /* NodeTypes.IF_BRANCH */: 2671 // noop 2672 break; 2673 default: 2674 if ((true)) { 2675 assert(false, `unhandled codegen node type: ${node.type}`); 2676 // make sure we exhaust all possible types 2677 const exhaustiveCheck = node; 2678 return exhaustiveCheck; 2679 } 2680 } 2681} 2682function genText(node, context) { 2683 context.push(JSON.stringify(node.content), node); 2684} 2685function genExpression(node, context) { 2686 const { content, isStatic } = node; 2687 context.push(isStatic ? JSON.stringify(content) : content, node); 2688} 2689function genInterpolation(node, context) { 2690 const { push, helper, pure } = context; 2691 if (pure) 2692 push(PURE_ANNOTATION); 2693 push(`${helper(TO_DISPLAY_STRING)}(`); 2694 genNode(node.content, context); 2695 push(`)`); 2696} 2697function genCompoundExpression(node, context) { 2698 for (let i = 0; i < node.children.length; i++) { 2699 const child = node.children[i]; 2700 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(child)) { 2701 context.push(child); 2702 } 2703 else { 2704 genNode(child, context); 2705 } 2706 } 2707} 2708function genExpressionAsPropertyKey(node, context) { 2709 const { push } = context; 2710 if (node.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */) { 2711 push(`[`); 2712 genCompoundExpression(node, context); 2713 push(`]`); 2714 } 2715 else if (node.isStatic) { 2716 // only quote keys if necessary 2717 const text = isSimpleIdentifier(node.content) 2718 ? node.content 2719 : JSON.stringify(node.content); 2720 push(text, node); 2721 } 2722 else { 2723 push(`[${node.content}]`, node); 2724 } 2725} 2726function genComment(node, context) { 2727 const { push, helper, pure } = context; 2728 if (pure) { 2729 push(PURE_ANNOTATION); 2730 } 2731 push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, node); 2732} 2733function genVNodeCall(node, context) { 2734 const { push, helper, pure } = context; 2735 const { tag, props, children, patchFlag, dynamicProps, directives, isBlock, disableTracking, isComponent } = node; 2736 if (directives) { 2737 push(helper(WITH_DIRECTIVES) + `(`); 2738 } 2739 if (isBlock) { 2740 push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `); 2741 } 2742 if (pure) { 2743 push(PURE_ANNOTATION); 2744 } 2745 const callHelper = isBlock 2746 ? getVNodeBlockHelper(context.inSSR, isComponent) 2747 : getVNodeHelper(context.inSSR, isComponent); 2748 push(helper(callHelper) + `(`, node); 2749 genNodeList(genNullableArgs([tag, props, children, patchFlag, dynamicProps]), context); 2750 push(`)`); 2751 if (isBlock) { 2752 push(`)`); 2753 } 2754 if (directives) { 2755 push(`, `); 2756 genNode(directives, context); 2757 push(`)`); 2758 } 2759} 2760function genNullableArgs(args) { 2761 let i = args.length; 2762 while (i--) { 2763 if (args[i] != null) 2764 break; 2765 } 2766 return args.slice(0, i + 1).map(arg => arg || `null`); 2767} 2768// JavaScript 2769function genCallExpression(node, context) { 2770 const { push, helper, pure } = context; 2771 const callee = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(node.callee) ? node.callee : helper(node.callee); 2772 if (pure) { 2773 push(PURE_ANNOTATION); 2774 } 2775 push(callee + `(`, node); 2776 genNodeList(node.arguments, context); 2777 push(`)`); 2778} 2779function genObjectExpression(node, context) { 2780 const { push, indent, deindent, newline } = context; 2781 const { properties } = node; 2782 if (!properties.length) { 2783 push(`{}`, node); 2784 return; 2785 } 2786 const multilines = properties.length > 1 || 2787 ((( true)) && 2788 properties.some(p => p.value.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */)); 2789 push(multilines ? `{` : `{ `); 2790 multilines && indent(); 2791 for (let i = 0; i < properties.length; i++) { 2792 const { key, value } = properties[i]; 2793 // key 2794 genExpressionAsPropertyKey(key, context); 2795 push(`: `); 2796 // value 2797 genNode(value, context); 2798 if (i < properties.length - 1) { 2799 // will only reach this if it's multilines 2800 push(`,`); 2801 newline(); 2802 } 2803 } 2804 multilines && deindent(); 2805 push(multilines ? `}` : ` }`); 2806} 2807function genArrayExpression(node, context) { 2808 genNodeListAsArray(node.elements, context); 2809} 2810function genFunctionExpression(node, context) { 2811 const { push, indent, deindent } = context; 2812 const { params, returns, body, newline, isSlot } = node; 2813 if (isSlot) { 2814 // wrap slot functions with owner context 2815 push(`_${helperNameMap[WITH_CTX]}(`); 2816 } 2817 push(`(`, node); 2818 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(params)) { 2819 genNodeList(params, context); 2820 } 2821 else if (params) { 2822 genNode(params, context); 2823 } 2824 push(`) => `); 2825 if (newline || body) { 2826 push(`{`); 2827 indent(); 2828 } 2829 if (returns) { 2830 if (newline) { 2831 push(`return `); 2832 } 2833 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(returns)) { 2834 genNodeListAsArray(returns, context); 2835 } 2836 else { 2837 genNode(returns, context); 2838 } 2839 } 2840 else if (body) { 2841 genNode(body, context); 2842 } 2843 if (newline || body) { 2844 deindent(); 2845 push(`}`); 2846 } 2847 if (isSlot) { 2848 if (node.isNonScopedSlot) { 2849 push(`, undefined, true`); 2850 } 2851 push(`)`); 2852 } 2853} 2854function genConditionalExpression(node, context) { 2855 const { test, consequent, alternate, newline: needNewline } = node; 2856 const { push, indent, deindent, newline } = context; 2857 if (test.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 2858 const needsParens = !isSimpleIdentifier(test.content); 2859 needsParens && push(`(`); 2860 genExpression(test, context); 2861 needsParens && push(`)`); 2862 } 2863 else { 2864 push(`(`); 2865 genNode(test, context); 2866 push(`)`); 2867 } 2868 needNewline && indent(); 2869 context.indentLevel++; 2870 needNewline || push(` `); 2871 push(`? `); 2872 genNode(consequent, context); 2873 context.indentLevel--; 2874 needNewline && newline(); 2875 needNewline || push(` `); 2876 push(`: `); 2877 const isNested = alternate.type === 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */; 2878 if (!isNested) { 2879 context.indentLevel++; 2880 } 2881 genNode(alternate, context); 2882 if (!isNested) { 2883 context.indentLevel--; 2884 } 2885 needNewline && deindent(true /* without newline */); 2886} 2887function genCacheExpression(node, context) { 2888 const { push, helper, indent, deindent, newline } = context; 2889 push(`_cache[${node.index}] || (`); 2890 if (node.isVNode) { 2891 indent(); 2892 push(`${helper(SET_BLOCK_TRACKING)}(-1),`); 2893 newline(); 2894 } 2895 push(`_cache[${node.index}] = `); 2896 genNode(node.value, context); 2897 if (node.isVNode) { 2898 push(`,`); 2899 newline(); 2900 push(`${helper(SET_BLOCK_TRACKING)}(1),`); 2901 newline(); 2902 push(`_cache[${node.index}]`); 2903 deindent(); 2904 } 2905 push(`)`); 2906} 2907 2908function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = Object.create(null)) { 2909 { 2910 return; 2911 } 2912} 2913function isReferencedIdentifier(id, parent, parentStack) { 2914 { 2915 return false; 2916 } 2917} 2918function isInDestructureAssignment(parent, parentStack) { 2919 if (parent && 2920 (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')) { 2921 let i = parentStack.length; 2922 while (i--) { 2923 const p = parentStack[i]; 2924 if (p.type === 'AssignmentExpression') { 2925 return true; 2926 } 2927 else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) { 2928 break; 2929 } 2930 } 2931 } 2932 return false; 2933} 2934function walkFunctionParams(node, onIdent) { 2935 for (const p of node.params) { 2936 for (const id of extractIdentifiers(p)) { 2937 onIdent(id); 2938 } 2939 } 2940} 2941function walkBlockDeclarations(block, onIdent) { 2942 for (const stmt of block.body) { 2943 if (stmt.type === 'VariableDeclaration') { 2944 if (stmt.declare) 2945 continue; 2946 for (const decl of stmt.declarations) { 2947 for (const id of extractIdentifiers(decl.id)) { 2948 onIdent(id); 2949 } 2950 } 2951 } 2952 else if (stmt.type === 'FunctionDeclaration' || 2953 stmt.type === 'ClassDeclaration') { 2954 if (stmt.declare || !stmt.id) 2955 continue; 2956 onIdent(stmt.id); 2957 } 2958 } 2959} 2960function extractIdentifiers(param, nodes = []) { 2961 switch (param.type) { 2962 case 'Identifier': 2963 nodes.push(param); 2964 break; 2965 case 'MemberExpression': 2966 let object = param; 2967 while (object.type === 'MemberExpression') { 2968 object = object.object; 2969 } 2970 nodes.push(object); 2971 break; 2972 case 'ObjectPattern': 2973 for (const prop of param.properties) { 2974 if (prop.type === 'RestElement') { 2975 extractIdentifiers(prop.argument, nodes); 2976 } 2977 else { 2978 extractIdentifiers(prop.value, nodes); 2979 } 2980 } 2981 break; 2982 case 'ArrayPattern': 2983 param.elements.forEach(element => { 2984 if (element) 2985 extractIdentifiers(element, nodes); 2986 }); 2987 break; 2988 case 'RestElement': 2989 extractIdentifiers(param.argument, nodes); 2990 break; 2991 case 'AssignmentPattern': 2992 extractIdentifiers(param.left, nodes); 2993 break; 2994 } 2995 return nodes; 2996} 2997const isFunctionType = (node) => { 2998 return /Function(?:Expression|Declaration)$|Method$/.test(node.type); 2999}; 3000const isStaticProperty = (node) => node && 3001 (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') && 3002 !node.computed; 3003const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node; 3004 3005// these keywords should not appear inside expressions, but operators like 3006// typeof, instanceof and in are allowed 3007const prohibitedKeywordRE = new RegExp('\\b' + 3008 ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' + 3009 'super,throw,while,yield,delete,export,import,return,switch,default,' + 3010 'extends,finally,continue,debugger,function,arguments,typeof,void') 3011 .split(',') 3012 .join('\\b|\\b') + 3013 '\\b'); 3014// strip strings in expressions 3015const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g; 3016/** 3017 * Validate a non-prefixed expression. 3018 * This is only called when using the in-browser runtime compiler since it 3019 * doesn't prefix expressions. 3020 */ 3021function validateBrowserExpression(node, context, asParams = false, asRawStatements = false) { 3022 const exp = node.content; 3023 // empty expressions are validated per-directive since some directives 3024 // do allow empty expressions. 3025 if (!exp.trim()) { 3026 return; 3027 } 3028 try { 3029 new Function(asRawStatements 3030 ? ` ${exp} ` 3031 : `return ${asParams ? `(${exp}) => {}` : `(${exp})`}`); 3032 } 3033 catch (e) { 3034 let message = e.message; 3035 const keywordMatch = exp 3036 .replace(stripStringRE, '') 3037 .match(prohibitedKeywordRE); 3038 if (keywordMatch) { 3039 message = `avoid using JavaScript keyword as property name: "${keywordMatch[0]}"`; 3040 } 3041 context.onError(createCompilerError(45 /* ErrorCodes.X_INVALID_EXPRESSION */, node.loc, undefined, message)); 3042 } 3043} 3044 3045const transformExpression = (node, context) => { 3046 if (node.type === 5 /* NodeTypes.INTERPOLATION */) { 3047 node.content = processExpression(node.content, context); 3048 } 3049 else if (node.type === 1 /* NodeTypes.ELEMENT */) { 3050 // handle directives on element 3051 for (let i = 0; i < node.props.length; i++) { 3052 const dir = node.props[i]; 3053 // do not process for v-on & v-for since they are special handled 3054 if (dir.type === 7 /* NodeTypes.DIRECTIVE */ && dir.name !== 'for') { 3055 const exp = dir.exp; 3056 const arg = dir.arg; 3057 // do not process exp if this is v-on:arg - we need special handling 3058 // for wrapping inline statements. 3059 if (exp && 3060 exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && 3061 !(dir.name === 'on' && arg)) { 3062 dir.exp = processExpression(exp, context, 3063 // slot args must be processed as function params 3064 dir.name === 'slot'); 3065 } 3066 if (arg && arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && !arg.isStatic) { 3067 dir.arg = processExpression(arg, context); 3068 } 3069 } 3070 } 3071 } 3072}; 3073// Important: since this function uses Node.js only dependencies, it should 3074// always be used with a leading !true check so that it can be 3075// tree-shaken from the browser build. 3076function processExpression(node, context, 3077// some expressions like v-slot props & v-for aliases should be parsed as 3078// function params 3079asParams = false, 3080// v-on handler values may contain multiple statements 3081asRawStatements = false, localVars = Object.create(context.identifiers)) { 3082 { 3083 if ((true)) { 3084 // simple in-browser validation (same logic in 2.x) 3085 validateBrowserExpression(node, context, asParams, asRawStatements); 3086 } 3087 return node; 3088 } 3089} 3090function stringifyExpression(exp) { 3091 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(exp)) { 3092 return exp; 3093 } 3094 else if (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 3095 return exp.content; 3096 } 3097 else { 3098 return exp.children 3099 .map(stringifyExpression) 3100 .join(''); 3101 } 3102} 3103 3104const transformIf = createStructuralDirectiveTransform(/^(if|else|else-if)$/, (node, dir, context) => { 3105 return processIf(node, dir, context, (ifNode, branch, isRoot) => { 3106 // #1587: We need to dynamically increment the key based on the current 3107 // node's sibling nodes, since chained v-if/else branches are 3108 // rendered at the same depth 3109 const siblings = context.parent.children; 3110 let i = siblings.indexOf(ifNode); 3111 let key = 0; 3112 while (i-- >= 0) { 3113 const sibling = siblings[i]; 3114 if (sibling && sibling.type === 9 /* NodeTypes.IF */) { 3115 key += sibling.branches.length; 3116 } 3117 } 3118 // Exit callback. Complete the codegenNode when all children have been 3119 // transformed. 3120 return () => { 3121 if (isRoot) { 3122 ifNode.codegenNode = createCodegenNodeForBranch(branch, key, context); 3123 } 3124 else { 3125 // attach this branch's codegen node to the v-if root. 3126 const parentCondition = getParentCondition(ifNode.codegenNode); 3127 parentCondition.alternate = createCodegenNodeForBranch(branch, key + ifNode.branches.length - 1, context); 3128 } 3129 }; 3130 }); 3131}); 3132// target-agnostic transform used for both Client and SSR 3133function processIf(node, dir, context, processCodegen) { 3134 if (dir.name !== 'else' && 3135 (!dir.exp || !dir.exp.content.trim())) { 3136 const loc = dir.exp ? dir.exp.loc : node.loc; 3137 context.onError(createCompilerError(28 /* ErrorCodes.X_V_IF_NO_EXPRESSION */, dir.loc)); 3138 dir.exp = createSimpleExpression(`true`, false, loc); 3139 } 3140 if ( true && dir.exp) { 3141 validateBrowserExpression(dir.exp, context); 3142 } 3143 if (dir.name === 'if') { 3144 const branch = createIfBranch(node, dir); 3145 const ifNode = { 3146 type: 9 /* NodeTypes.IF */, 3147 loc: node.loc, 3148 branches: [branch] 3149 }; 3150 context.replaceNode(ifNode); 3151 if (processCodegen) { 3152 return processCodegen(ifNode, branch, true); 3153 } 3154 } 3155 else { 3156 // locate the adjacent v-if 3157 const siblings = context.parent.children; 3158 const comments = []; 3159 let i = siblings.indexOf(node); 3160 while (i-- >= -1) { 3161 const sibling = siblings[i]; 3162 if (sibling && sibling.type === 3 /* NodeTypes.COMMENT */) { 3163 context.removeNode(sibling); 3164 ( true) && comments.unshift(sibling); 3165 continue; 3166 } 3167 if (sibling && 3168 sibling.type === 2 /* NodeTypes.TEXT */ && 3169 !sibling.content.trim().length) { 3170 context.removeNode(sibling); 3171 continue; 3172 } 3173 if (sibling && sibling.type === 9 /* NodeTypes.IF */) { 3174 // Check if v-else was followed by v-else-if 3175 if (dir.name === 'else-if' && 3176 sibling.branches[sibling.branches.length - 1].condition === undefined) { 3177 context.onError(createCompilerError(30 /* ErrorCodes.X_V_ELSE_NO_ADJACENT_IF */, node.loc)); 3178 } 3179 // move the node to the if node's branches 3180 context.removeNode(); 3181 const branch = createIfBranch(node, dir); 3182 if (( true) && 3183 comments.length && 3184 // #3619 ignore comments if the v-if is direct child of <transition> 3185 !(context.parent && 3186 context.parent.type === 1 /* NodeTypes.ELEMENT */ && 3187 isBuiltInType(context.parent.tag, 'transition'))) { 3188 branch.children = [...comments, ...branch.children]; 3189 } 3190 // check if user is forcing same key on different branches 3191 if (true) { 3192 const key = branch.userKey; 3193 if (key) { 3194 sibling.branches.forEach(({ userKey }) => { 3195 if (isSameKey(userKey, key)) { 3196 context.onError(createCompilerError(29 /* ErrorCodes.X_V_IF_SAME_KEY */, branch.userKey.loc)); 3197 } 3198 }); 3199 } 3200 } 3201 sibling.branches.push(branch); 3202 const onExit = processCodegen && processCodegen(sibling, branch, false); 3203 // since the branch was removed, it will not be traversed. 3204 // make sure to traverse here. 3205 traverseNode(branch, context); 3206 // call on exit 3207 if (onExit) 3208 onExit(); 3209 // make sure to reset currentNode after traversal to indicate this 3210 // node has been removed. 3211 context.currentNode = null; 3212 } 3213 else { 3214 context.onError(createCompilerError(30 /* ErrorCodes.X_V_ELSE_NO_ADJACENT_IF */, node.loc)); 3215 } 3216 break; 3217 } 3218 } 3219} 3220function createIfBranch(node, dir) { 3221 const isTemplateIf = node.tagType === 3 /* ElementTypes.TEMPLATE */; 3222 return { 3223 type: 10 /* NodeTypes.IF_BRANCH */, 3224 loc: node.loc, 3225 condition: dir.name === 'else' ? undefined : dir.exp, 3226 children: isTemplateIf && !findDir(node, 'for') ? node.children : [node], 3227 userKey: findProp(node, `key`), 3228 isTemplateIf 3229 }; 3230} 3231function createCodegenNodeForBranch(branch, keyIndex, context) { 3232 if (branch.condition) { 3233 return createConditionalExpression(branch.condition, createChildrenCodegenNode(branch, keyIndex, context), 3234 // make sure to pass in asBlock: true so that the comment node call 3235 // closes the current block. 3236 createCallExpression(context.helper(CREATE_COMMENT), [ 3237 ( true) ? '"v-if"' : 0, 3238 'true' 3239 ])); 3240 } 3241 else { 3242 return createChildrenCodegenNode(branch, keyIndex, context); 3243 } 3244} 3245function createChildrenCodegenNode(branch, keyIndex, context) { 3246 const { helper } = context; 3247 const keyProperty = createObjectProperty(`key`, createSimpleExpression(`${keyIndex}`, false, locStub, 2 /* ConstantTypes.CAN_HOIST */)); 3248 const { children } = branch; 3249 const firstChild = children[0]; 3250 const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1 /* NodeTypes.ELEMENT */; 3251 if (needFragmentWrapper) { 3252 if (children.length === 1 && firstChild.type === 11 /* NodeTypes.FOR */) { 3253 // optimize away nested fragments when child is a ForNode 3254 const vnodeCall = firstChild.codegenNode; 3255 injectProp(vnodeCall, keyProperty, context); 3256 return vnodeCall; 3257 } 3258 else { 3259 let patchFlag = 64 /* PatchFlags.STABLE_FRAGMENT */; 3260 let patchFlagText = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[64]; 3261 // check if the fragment actually contains a single valid child with 3262 // the rest being comments 3263 if (( true) && 3264 !branch.isTemplateIf && 3265 children.filter(c => c.type !== 3 /* NodeTypes.COMMENT */).length === 1) { 3266 patchFlag |= 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */; 3267 patchFlagText += `, ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[2048]}`; 3268 } 3269 return createVNodeCall(context, helper(FRAGMENT), createObjectExpression([keyProperty]), children, patchFlag + (( true) ? ` /* ${patchFlagText} */` : 0), undefined, undefined, true, false, false /* isComponent */, branch.loc); 3270 } 3271 } 3272 else { 3273 const ret = firstChild.codegenNode; 3274 const vnodeCall = getMemoedVNodeCall(ret); 3275 // Change createVNode to createBlock. 3276 if (vnodeCall.type === 13 /* NodeTypes.VNODE_CALL */) { 3277 makeBlock(vnodeCall, context); 3278 } 3279 // inject branch key 3280 injectProp(vnodeCall, keyProperty, context); 3281 return ret; 3282 } 3283} 3284function isSameKey(a, b) { 3285 if (!a || a.type !== b.type) { 3286 return false; 3287 } 3288 if (a.type === 6 /* NodeTypes.ATTRIBUTE */) { 3289 if (a.value.content !== b.value.content) { 3290 return false; 3291 } 3292 } 3293 else { 3294 // directive 3295 const exp = a.exp; 3296 const branchExp = b.exp; 3297 if (exp.type !== branchExp.type) { 3298 return false; 3299 } 3300 if (exp.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */ || 3301 exp.isStatic !== branchExp.isStatic || 3302 exp.content !== branchExp.content) { 3303 return false; 3304 } 3305 } 3306 return true; 3307} 3308function getParentCondition(node) { 3309 while (true) { 3310 if (node.type === 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */) { 3311 if (node.alternate.type === 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */) { 3312 node = node.alternate; 3313 } 3314 else { 3315 return node; 3316 } 3317 } 3318 else if (node.type === 20 /* NodeTypes.JS_CACHE_EXPRESSION */) { 3319 node = node.value; 3320 } 3321 } 3322} 3323 3324const transformFor = createStructuralDirectiveTransform('for', (node, dir, context) => { 3325 const { helper, removeHelper } = context; 3326 return processFor(node, dir, context, forNode => { 3327 // create the loop render function expression now, and add the 3328 // iterator on exit after all children have been traversed 3329 const renderExp = createCallExpression(helper(RENDER_LIST), [ 3330 forNode.source 3331 ]); 3332 const isTemplate = isTemplateNode(node); 3333 const memo = findDir(node, 'memo'); 3334 const keyProp = findProp(node, `key`); 3335 const keyExp = keyProp && 3336 (keyProp.type === 6 /* NodeTypes.ATTRIBUTE */ 3337 ? createSimpleExpression(keyProp.value.content, true) 3338 : keyProp.exp); 3339 const keyProperty = keyProp ? createObjectProperty(`key`, keyExp) : null; 3340 const isStableFragment = forNode.source.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && 3341 forNode.source.constType > 0 /* ConstantTypes.NOT_CONSTANT */; 3342 const fragmentFlag = isStableFragment 3343 ? 64 /* PatchFlags.STABLE_FRAGMENT */ 3344 : keyProp 3345 ? 128 /* PatchFlags.KEYED_FRAGMENT */ 3346 : 256 /* PatchFlags.UNKEYED_FRAGMENT */; 3347 forNode.codegenNode = createVNodeCall(context, helper(FRAGMENT), undefined, renderExp, fragmentFlag + 3348 (( true) ? ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[fragmentFlag]} */` : 0), undefined, undefined, true /* isBlock */, !isStableFragment /* disableTracking */, false /* isComponent */, node.loc); 3349 return () => { 3350 // finish the codegen now that all children have been traversed 3351 let childBlock; 3352 const { children } = forNode; 3353 // check <template v-for> key placement 3354 if (( true) && isTemplate) { 3355 node.children.some(c => { 3356 if (c.type === 1 /* NodeTypes.ELEMENT */) { 3357 const key = findProp(c, 'key'); 3358 if (key) { 3359 context.onError(createCompilerError(33 /* ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT */, key.loc)); 3360 return true; 3361 } 3362 } 3363 }); 3364 } 3365 const needFragmentWrapper = children.length !== 1 || children[0].type !== 1 /* NodeTypes.ELEMENT */; 3366 const slotOutlet = isSlotOutlet(node) 3367 ? node 3368 : isTemplate && 3369 node.children.length === 1 && 3370 isSlotOutlet(node.children[0]) 3371 ? node.children[0] // api-extractor somehow fails to infer this 3372 : null; 3373 if (slotOutlet) { 3374 // <slot v-for="..."> or <template v-for="..."><slot/></template> 3375 childBlock = slotOutlet.codegenNode; 3376 if (isTemplate && keyProperty) { 3377 // <template v-for="..." :key="..."><slot/></template> 3378 // we need to inject the key to the renderSlot() call. 3379 // the props for renderSlot is passed as the 3rd argument. 3380 injectProp(childBlock, keyProperty, context); 3381 } 3382 } 3383 else if (needFragmentWrapper) { 3384 // <template v-for="..."> with text or multi-elements 3385 // should generate a fragment block for each loop 3386 childBlock = createVNodeCall(context, helper(FRAGMENT), keyProperty ? createObjectExpression([keyProperty]) : undefined, node.children, 64 /* PatchFlags.STABLE_FRAGMENT */ + 3387 (( true) 3388 ? ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[64]} */` 3389 : 0), undefined, undefined, true, undefined, false /* isComponent */); 3390 } 3391 else { 3392 // Normal element v-for. Directly use the child's codegenNode 3393 // but mark it as a block. 3394 childBlock = children[0] 3395 .codegenNode; 3396 if (isTemplate && keyProperty) { 3397 injectProp(childBlock, keyProperty, context); 3398 } 3399 if (childBlock.isBlock !== !isStableFragment) { 3400 if (childBlock.isBlock) { 3401 // switch from block to vnode 3402 removeHelper(OPEN_BLOCK); 3403 removeHelper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)); 3404 } 3405 else { 3406 // switch from vnode to block 3407 removeHelper(getVNodeHelper(context.inSSR, childBlock.isComponent)); 3408 } 3409 } 3410 childBlock.isBlock = !isStableFragment; 3411 if (childBlock.isBlock) { 3412 helper(OPEN_BLOCK); 3413 helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)); 3414 } 3415 else { 3416 helper(getVNodeHelper(context.inSSR, childBlock.isComponent)); 3417 } 3418 } 3419 if (memo) { 3420 const loop = createFunctionExpression(createForLoopParams(forNode.parseResult, [ 3421 createSimpleExpression(`_cached`) 3422 ])); 3423 loop.body = createBlockStatement([ 3424 createCompoundExpression([`const _memo = (`, memo.exp, `)`]), 3425 createCompoundExpression([ 3426 `if (_cached`, 3427 ...(keyExp ? [` && _cached.key === `, keyExp] : []), 3428 ` && ${context.helperString(IS_MEMO_SAME)}(_cached, _memo)) return _cached` 3429 ]), 3430 createCompoundExpression([`const _item = `, childBlock]), 3431 createSimpleExpression(`_item.memo = _memo`), 3432 createSimpleExpression(`return _item`) 3433 ]); 3434 renderExp.arguments.push(loop, createSimpleExpression(`_cache`), createSimpleExpression(String(context.cached++))); 3435 } 3436 else { 3437 renderExp.arguments.push(createFunctionExpression(createForLoopParams(forNode.parseResult), childBlock, true /* force newline */)); 3438 } 3439 }; 3440 }); 3441}); 3442// target-agnostic transform used for both Client and SSR 3443function processFor(node, dir, context, processCodegen) { 3444 if (!dir.exp) { 3445 context.onError(createCompilerError(31 /* ErrorCodes.X_V_FOR_NO_EXPRESSION */, dir.loc)); 3446 return; 3447 } 3448 const parseResult = parseForExpression( 3449 // can only be simple expression because vFor transform is applied 3450 // before expression transform. 3451 dir.exp, context); 3452 if (!parseResult) { 3453 context.onError(createCompilerError(32 /* ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION */, dir.loc)); 3454 return; 3455 } 3456 const { addIdentifiers, removeIdentifiers, scopes } = context; 3457 const { source, value, key, index } = parseResult; 3458 const forNode = { 3459 type: 11 /* NodeTypes.FOR */, 3460 loc: dir.loc, 3461 source, 3462 valueAlias: value, 3463 keyAlias: key, 3464 objectIndexAlias: index, 3465 parseResult, 3466 children: isTemplateNode(node) ? node.children : [node] 3467 }; 3468 context.replaceNode(forNode); 3469 // bookkeeping 3470 scopes.vFor++; 3471 const onExit = processCodegen && processCodegen(forNode); 3472 return () => { 3473 scopes.vFor--; 3474 if (onExit) 3475 onExit(); 3476 }; 3477} 3478const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/; 3479// This regex doesn't cover the case if key or index aliases have destructuring, 3480// but those do not make sense in the first place, so this works in practice. 3481const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/; 3482const stripParensRE = /^\(|\)$/g; 3483function parseForExpression(input, context) { 3484 const loc = input.loc; 3485 const exp = input.content; 3486 const inMatch = exp.match(forAliasRE); 3487 if (!inMatch) 3488 return; 3489 const [, LHS, RHS] = inMatch; 3490 const result = { 3491 source: createAliasExpression(loc, RHS.trim(), exp.indexOf(RHS, LHS.length)), 3492 value: undefined, 3493 key: undefined, 3494 index: undefined 3495 }; 3496 if (true) { 3497 validateBrowserExpression(result.source, context); 3498 } 3499 let valueContent = LHS.trim().replace(stripParensRE, '').trim(); 3500 const trimmedOffset = LHS.indexOf(valueContent); 3501 const iteratorMatch = valueContent.match(forIteratorRE); 3502 if (iteratorMatch) { 3503 valueContent = valueContent.replace(forIteratorRE, '').trim(); 3504 const keyContent = iteratorMatch[1].trim(); 3505 let keyOffset; 3506 if (keyContent) { 3507 keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length); 3508 result.key = createAliasExpression(loc, keyContent, keyOffset); 3509 if (true) { 3510 validateBrowserExpression(result.key, context, true); 3511 } 3512 } 3513 if (iteratorMatch[2]) { 3514 const indexContent = iteratorMatch[2].trim(); 3515 if (indexContent) { 3516 result.index = createAliasExpression(loc, indexContent, exp.indexOf(indexContent, result.key 3517 ? keyOffset + keyContent.length 3518 : trimmedOffset + valueContent.length)); 3519 if (true) { 3520 validateBrowserExpression(result.index, context, true); 3521 } 3522 } 3523 } 3524 } 3525 if (valueContent) { 3526 result.value = createAliasExpression(loc, valueContent, trimmedOffset); 3527 if (true) { 3528 validateBrowserExpression(result.value, context, true); 3529 } 3530 } 3531 return result; 3532} 3533function createAliasExpression(range, content, offset) { 3534 return createSimpleExpression(content, false, getInnerRange(range, offset, content.length)); 3535} 3536function createForLoopParams({ value, key, index }, memoArgs = []) { 3537 return createParamsList([value, key, index, ...memoArgs]); 3538} 3539function createParamsList(args) { 3540 let i = args.length; 3541 while (i--) { 3542 if (args[i]) 3543 break; 3544 } 3545 return args 3546 .slice(0, i + 1) 3547 .map((arg, i) => arg || createSimpleExpression(`_`.repeat(i + 1), false)); 3548} 3549 3550const defaultFallback = createSimpleExpression(`undefined`, false); 3551// A NodeTransform that: 3552// 1. Tracks scope identifiers for scoped slots so that they don't get prefixed 3553// by transformExpression. This is only applied in non-browser builds with 3554// { prefixIdentifiers: true }. 3555// 2. Track v-slot depths so that we know a slot is inside another slot. 3556// Note the exit callback is executed before buildSlots() on the same node, 3557// so only nested slots see positive numbers. 3558const trackSlotScopes = (node, context) => { 3559 if (node.type === 1 /* NodeTypes.ELEMENT */ && 3560 (node.tagType === 1 /* ElementTypes.COMPONENT */ || 3561 node.tagType === 3 /* ElementTypes.TEMPLATE */)) { 3562 // We are only checking non-empty v-slot here 3563 // since we only care about slots that introduce scope variables. 3564 const vSlot = findDir(node, 'slot'); 3565 if (vSlot) { 3566 vSlot.exp; 3567 context.scopes.vSlot++; 3568 return () => { 3569 context.scopes.vSlot--; 3570 }; 3571 } 3572 } 3573}; 3574// A NodeTransform that tracks scope identifiers for scoped slots with v-for. 3575// This transform is only applied in non-browser builds with { prefixIdentifiers: true } 3576const trackVForSlotScopes = (node, context) => { 3577 let vFor; 3578 if (isTemplateNode(node) && 3579 node.props.some(isVSlot) && 3580 (vFor = findDir(node, 'for'))) { 3581 const result = (vFor.parseResult = parseForExpression(vFor.exp, context)); 3582 if (result) { 3583 const { value, key, index } = result; 3584 const { addIdentifiers, removeIdentifiers } = context; 3585 value && addIdentifiers(value); 3586 key && addIdentifiers(key); 3587 index && addIdentifiers(index); 3588 return () => { 3589 value && removeIdentifiers(value); 3590 key && removeIdentifiers(key); 3591 index && removeIdentifiers(index); 3592 }; 3593 } 3594 } 3595}; 3596const buildClientSlotFn = (props, children, loc) => createFunctionExpression(props, children, false /* newline */, true /* isSlot */, children.length ? children[0].loc : loc); 3597// Instead of being a DirectiveTransform, v-slot processing is called during 3598// transformElement to build the slots object for a component. 3599function buildSlots(node, context, buildSlotFn = buildClientSlotFn) { 3600 context.helper(WITH_CTX); 3601 const { children, loc } = node; 3602 const slotsProperties = []; 3603 const dynamicSlots = []; 3604 // If the slot is inside a v-for or another v-slot, force it to be dynamic 3605 // since it likely uses a scope variable. 3606 let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0; 3607 // 1. Check for slot with slotProps on component itself. 3608 // <Comp v-slot="{ prop }"/> 3609 const onComponentSlot = findDir(node, 'slot', true); 3610 if (onComponentSlot) { 3611 const { arg, exp } = onComponentSlot; 3612 if (arg && !isStaticExp(arg)) { 3613 hasDynamicSlots = true; 3614 } 3615 slotsProperties.push(createObjectProperty(arg || createSimpleExpression('default', true), buildSlotFn(exp, children, loc))); 3616 } 3617 // 2. Iterate through children and check for template slots 3618 // <template v-slot:foo="{ prop }"> 3619 let hasTemplateSlots = false; 3620 let hasNamedDefaultSlot = false; 3621 const implicitDefaultChildren = []; 3622 const seenSlotNames = new Set(); 3623 let conditionalBranchIndex = 0; 3624 for (let i = 0; i < children.length; i++) { 3625 const slotElement = children[i]; 3626 let slotDir; 3627 if (!isTemplateNode(slotElement) || 3628 !(slotDir = findDir(slotElement, 'slot', true))) { 3629 // not a <template v-slot>, skip. 3630 if (slotElement.type !== 3 /* NodeTypes.COMMENT */) { 3631 implicitDefaultChildren.push(slotElement); 3632 } 3633 continue; 3634 } 3635 if (onComponentSlot) { 3636 // already has on-component slot - this is incorrect usage. 3637 context.onError(createCompilerError(37 /* ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE */, slotDir.loc)); 3638 break; 3639 } 3640 hasTemplateSlots = true; 3641 const { children: slotChildren, loc: slotLoc } = slotElement; 3642 const { arg: slotName = createSimpleExpression(`default`, true), exp: slotProps, loc: dirLoc } = slotDir; 3643 // check if name is dynamic. 3644 let staticSlotName; 3645 if (isStaticExp(slotName)) { 3646 staticSlotName = slotName ? slotName.content : `default`; 3647 } 3648 else { 3649 hasDynamicSlots = true; 3650 } 3651 const slotFunction = buildSlotFn(slotProps, slotChildren, slotLoc); 3652 // check if this slot is conditional (v-if/v-for) 3653 let vIf; 3654 let vElse; 3655 let vFor; 3656 if ((vIf = findDir(slotElement, 'if'))) { 3657 hasDynamicSlots = true; 3658 dynamicSlots.push(createConditionalExpression(vIf.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback)); 3659 } 3660 else if ((vElse = findDir(slotElement, /^else(-if)?$/, true /* allowEmpty */))) { 3661 // find adjacent v-if 3662 let j = i; 3663 let prev; 3664 while (j--) { 3665 prev = children[j]; 3666 if (prev.type !== 3 /* NodeTypes.COMMENT */) { 3667 break; 3668 } 3669 } 3670 if (prev && isTemplateNode(prev) && findDir(prev, 'if')) { 3671 // remove node 3672 children.splice(i, 1); 3673 i--; 3674 // attach this slot to previous conditional 3675 let conditional = dynamicSlots[dynamicSlots.length - 1]; 3676 while (conditional.alternate.type === 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */) { 3677 conditional = conditional.alternate; 3678 } 3679 conditional.alternate = vElse.exp 3680 ? createConditionalExpression(vElse.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback) 3681 : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++); 3682 } 3683 else { 3684 context.onError(createCompilerError(30 /* ErrorCodes.X_V_ELSE_NO_ADJACENT_IF */, vElse.loc)); 3685 } 3686 } 3687 else if ((vFor = findDir(slotElement, 'for'))) { 3688 hasDynamicSlots = true; 3689 const parseResult = vFor.parseResult || 3690 parseForExpression(vFor.exp, context); 3691 if (parseResult) { 3692 // Render the dynamic slots as an array and add it to the createSlot() 3693 // args. The runtime knows how to handle it appropriately. 3694 dynamicSlots.push(createCallExpression(context.helper(RENDER_LIST), [ 3695 parseResult.source, 3696 createFunctionExpression(createForLoopParams(parseResult), buildDynamicSlot(slotName, slotFunction), true /* force newline */) 3697 ])); 3698 } 3699 else { 3700 context.onError(createCompilerError(32 /* ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION */, vFor.loc)); 3701 } 3702 } 3703 else { 3704 // check duplicate static names 3705 if (staticSlotName) { 3706 if (seenSlotNames.has(staticSlotName)) { 3707 context.onError(createCompilerError(38 /* ErrorCodes.X_V_SLOT_DUPLICATE_SLOT_NAMES */, dirLoc)); 3708 continue; 3709 } 3710 seenSlotNames.add(staticSlotName); 3711 if (staticSlotName === 'default') { 3712 hasNamedDefaultSlot = true; 3713 } 3714 } 3715 slotsProperties.push(createObjectProperty(slotName, slotFunction)); 3716 } 3717 } 3718 if (!onComponentSlot) { 3719 const buildDefaultSlotProperty = (props, children) => { 3720 const fn = buildSlotFn(props, children, loc); 3721 if (context.compatConfig) { 3722 fn.isNonScopedSlot = true; 3723 } 3724 return createObjectProperty(`default`, fn); 3725 }; 3726 if (!hasTemplateSlots) { 3727 // implicit default slot (on component) 3728 slotsProperties.push(buildDefaultSlotProperty(undefined, children)); 3729 } 3730 else if (implicitDefaultChildren.length && 3731 // #3766 3732 // with whitespace: 'preserve', whitespaces between slots will end up in 3733 // implicitDefaultChildren. Ignore if all implicit children are whitespaces. 3734 implicitDefaultChildren.some(node => isNonWhitespaceContent(node))) { 3735 // implicit default slot (mixed with named slots) 3736 if (hasNamedDefaultSlot) { 3737 context.onError(createCompilerError(39 /* ErrorCodes.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN */, implicitDefaultChildren[0].loc)); 3738 } 3739 else { 3740 slotsProperties.push(buildDefaultSlotProperty(undefined, implicitDefaultChildren)); 3741 } 3742 } 3743 } 3744 const slotFlag = hasDynamicSlots 3745 ? 2 /* SlotFlags.DYNAMIC */ 3746 : hasForwardedSlots(node.children) 3747 ? 3 /* SlotFlags.FORWARDED */ 3748 : 1 /* SlotFlags.STABLE */; 3749 let slots = createObjectExpression(slotsProperties.concat(createObjectProperty(`_`, 3750 // 2 = compiled but dynamic = can skip normalization, but must run diff 3751 // 1 = compiled and static = can skip normalization AND diff as optimized 3752 createSimpleExpression(slotFlag + (( true) ? ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.slotFlagsText[slotFlag]} */` : 0), false))), loc); 3753 if (dynamicSlots.length) { 3754 slots = createCallExpression(context.helper(CREATE_SLOTS), [ 3755 slots, 3756 createArrayExpression(dynamicSlots) 3757 ]); 3758 } 3759 return { 3760 slots, 3761 hasDynamicSlots 3762 }; 3763} 3764function buildDynamicSlot(name, fn, index) { 3765 const props = [ 3766 createObjectProperty(`name`, name), 3767 createObjectProperty(`fn`, fn) 3768 ]; 3769 if (index != null) { 3770 props.push(createObjectProperty(`key`, createSimpleExpression(String(index), true))); 3771 } 3772 return createObjectExpression(props); 3773} 3774function hasForwardedSlots(children) { 3775 for (let i = 0; i < children.length; i++) { 3776 const child = children[i]; 3777 switch (child.type) { 3778 case 1 /* NodeTypes.ELEMENT */: 3779 if (child.tagType === 2 /* ElementTypes.SLOT */ || 3780 hasForwardedSlots(child.children)) { 3781 return true; 3782 } 3783 break; 3784 case 9 /* NodeTypes.IF */: 3785 if (hasForwardedSlots(child.branches)) 3786 return true; 3787 break; 3788 case 10 /* NodeTypes.IF_BRANCH */: 3789 case 11 /* NodeTypes.FOR */: 3790 if (hasForwardedSlots(child.children)) 3791 return true; 3792 break; 3793 } 3794 } 3795 return false; 3796} 3797function isNonWhitespaceContent(node) { 3798 if (node.type !== 2 /* NodeTypes.TEXT */ && node.type !== 12 /* NodeTypes.TEXT_CALL */) 3799 return true; 3800 return node.type === 2 /* NodeTypes.TEXT */ 3801 ? !!node.content.trim() 3802 : isNonWhitespaceContent(node.content); 3803} 3804 3805// some directive transforms (e.g. v-model) may return a symbol for runtime 3806// import, which should be used instead of a resolveDirective call. 3807const directiveImportMap = new WeakMap(); 3808// generate a JavaScript AST for this element's codegen 3809const transformElement = (node, context) => { 3810 // perform the work on exit, after all child expressions have been 3811 // processed and merged. 3812 return function postTransformElement() { 3813 node = context.currentNode; 3814 if (!(node.type === 1 /* NodeTypes.ELEMENT */ && 3815 (node.tagType === 0 /* ElementTypes.ELEMENT */ || 3816 node.tagType === 1 /* ElementTypes.COMPONENT */))) { 3817 return; 3818 } 3819 const { tag, props } = node; 3820 const isComponent = node.tagType === 1 /* ElementTypes.COMPONENT */; 3821 // The goal of the transform is to create a codegenNode implementing the 3822 // VNodeCall interface. 3823 let vnodeTag = isComponent 3824 ? resolveComponentType(node, context) 3825 : `"${tag}"`; 3826 const isDynamicComponent = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT; 3827 let vnodeProps; 3828 let vnodeChildren; 3829 let vnodePatchFlag; 3830 let patchFlag = 0; 3831 let vnodeDynamicProps; 3832 let dynamicPropNames; 3833 let vnodeDirectives; 3834 let shouldUseBlock = 3835 // dynamic component may resolve to plain elements 3836 isDynamicComponent || 3837 vnodeTag === TELEPORT || 3838 vnodeTag === SUSPENSE || 3839 (!isComponent && 3840 // <svg> and <foreignObject> must be forced into blocks so that block 3841 // updates inside get proper isSVG flag at runtime. (#639, #643) 3842 // This is technically web-specific, but splitting the logic out of core 3843 // leads to too much unnecessary complexity. 3844 (tag === 'svg' || tag === 'foreignObject')); 3845 // props 3846 if (props.length > 0) { 3847 const propsBuildResult = buildProps(node, context, undefined, isComponent, isDynamicComponent); 3848 vnodeProps = propsBuildResult.props; 3849 patchFlag = propsBuildResult.patchFlag; 3850 dynamicPropNames = propsBuildResult.dynamicPropNames; 3851 const directives = propsBuildResult.directives; 3852 vnodeDirectives = 3853 directives && directives.length 3854 ? createArrayExpression(directives.map(dir => buildDirectiveArgs(dir, context))) 3855 : undefined; 3856 if (propsBuildResult.shouldUseBlock) { 3857 shouldUseBlock = true; 3858 } 3859 } 3860 // children 3861 if (node.children.length > 0) { 3862 if (vnodeTag === KEEP_ALIVE) { 3863 // Although a built-in component, we compile KeepAlive with raw children 3864 // instead of slot functions so that it can be used inside Transition 3865 // or other Transition-wrapping HOCs. 3866 // To ensure correct updates with block optimizations, we need to: 3867 // 1. Force keep-alive into a block. This avoids its children being 3868 // collected by a parent block. 3869 shouldUseBlock = true; 3870 // 2. Force keep-alive to always be updated, since it uses raw children. 3871 patchFlag |= 1024 /* PatchFlags.DYNAMIC_SLOTS */; 3872 if (( true) && node.children.length > 1) { 3873 context.onError(createCompilerError(46 /* ErrorCodes.X_KEEP_ALIVE_INVALID_CHILDREN */, { 3874 start: node.children[0].loc.start, 3875 end: node.children[node.children.length - 1].loc.end, 3876 source: '' 3877 })); 3878 } 3879 } 3880 const shouldBuildAsSlots = isComponent && 3881 // Teleport is not a real component and has dedicated runtime handling 3882 vnodeTag !== TELEPORT && 3883 // explained above. 3884 vnodeTag !== KEEP_ALIVE; 3885 if (shouldBuildAsSlots) { 3886 const { slots, hasDynamicSlots } = buildSlots(node, context); 3887 vnodeChildren = slots; 3888 if (hasDynamicSlots) { 3889 patchFlag |= 1024 /* PatchFlags.DYNAMIC_SLOTS */; 3890 } 3891 } 3892 else if (node.children.length === 1 && vnodeTag !== TELEPORT) { 3893 const child = node.children[0]; 3894 const type = child.type; 3895 // check for dynamic text children 3896 const hasDynamicTextChild = type === 5 /* NodeTypes.INTERPOLATION */ || 3897 type === 8 /* NodeTypes.COMPOUND_EXPRESSION */; 3898 if (hasDynamicTextChild && 3899 getConstantType(child, context) === 0 /* ConstantTypes.NOT_CONSTANT */) { 3900 patchFlag |= 1 /* PatchFlags.TEXT */; 3901 } 3902 // pass directly if the only child is a text node 3903 // (plain / interpolation / expression) 3904 if (hasDynamicTextChild || type === 2 /* NodeTypes.TEXT */) { 3905 vnodeChildren = child; 3906 } 3907 else { 3908 vnodeChildren = node.children; 3909 } 3910 } 3911 else { 3912 vnodeChildren = node.children; 3913 } 3914 } 3915 // patchFlag & dynamicPropNames 3916 if (patchFlag !== 0) { 3917 if ((true)) { 3918 if (patchFlag < 0) { 3919 // special flags (negative and mutually exclusive) 3920 vnodePatchFlag = patchFlag + ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[patchFlag]} */`; 3921 } 3922 else { 3923 // bitwise flags 3924 const flagNames = Object.keys(_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames) 3925 .map(Number) 3926 .filter(n => n > 0 && patchFlag & n) 3927 .map(n => _vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[n]) 3928 .join(`, `); 3929 vnodePatchFlag = patchFlag + ` /* ${flagNames} */`; 3930 } 3931 } 3932 else {} 3933 if (dynamicPropNames && dynamicPropNames.length) { 3934 vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames); 3935 } 3936 } 3937 node.codegenNode = createVNodeCall(context, vnodeTag, vnodeProps, vnodeChildren, vnodePatchFlag, vnodeDynamicProps, vnodeDirectives, !!shouldUseBlock, false /* disableTracking */, isComponent, node.loc); 3938 }; 3939}; 3940function resolveComponentType(node, context, ssr = false) { 3941 let { tag } = node; 3942 // 1. dynamic component 3943 const isExplicitDynamic = isComponentTag(tag); 3944 const isProp = findProp(node, 'is'); 3945 if (isProp) { 3946 if (isExplicitDynamic || 3947 (isCompatEnabled("COMPILER_IS_ON_ELEMENT" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */, context))) { 3948 const exp = isProp.type === 6 /* NodeTypes.ATTRIBUTE */ 3949 ? isProp.value && createSimpleExpression(isProp.value.content, true) 3950 : isProp.exp; 3951 if (exp) { 3952 return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [ 3953 exp 3954 ]); 3955 } 3956 } 3957 else if (isProp.type === 6 /* NodeTypes.ATTRIBUTE */ && 3958 isProp.value.content.startsWith('vue:')) { 3959 // <button is="vue:xxx"> 3960 // if not <component>, only is value that starts with "vue:" will be 3961 // treated as component by the parse phase and reach here, unless it's 3962 // compat mode where all is values are considered components 3963 tag = isProp.value.content.slice(4); 3964 } 3965 } 3966 // 1.5 v-is (TODO: Deprecate) 3967 const isDir = !isExplicitDynamic && findDir(node, 'is'); 3968 if (isDir && isDir.exp) { 3969 return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [ 3970 isDir.exp 3971 ]); 3972 } 3973 // 2. built-in components (Teleport, Transition, KeepAlive, Suspense...) 3974 const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag); 3975 if (builtIn) { 3976 // built-ins are simply fallthroughs / have special handling during ssr 3977 // so we don't need to import their runtime equivalents 3978 if (!ssr) 3979 context.helper(builtIn); 3980 return builtIn; 3981 } 3982 // 5. user component (resolve) 3983 context.helper(RESOLVE_COMPONENT); 3984 context.components.add(tag); 3985 return toValidAssetId(tag, `component`); 3986} 3987function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) { 3988 const { tag, loc: elementLoc, children } = node; 3989 let properties = []; 3990 const mergeArgs = []; 3991 const runtimeDirectives = []; 3992 const hasChildren = children.length > 0; 3993 let shouldUseBlock = false; 3994 // patchFlag analysis 3995 let patchFlag = 0; 3996 let hasRef = false; 3997 let hasClassBinding = false; 3998 let hasStyleBinding = false; 3999 let hasHydrationEventBinding = false; 4000 let hasDynamicKeys = false; 4001 let hasVnodeHook = false; 4002 const dynamicPropNames = []; 4003 const pushMergeArg = (arg) => { 4004 if (properties.length) { 4005 mergeArgs.push(createObjectExpression(dedupeProperties(properties), elementLoc)); 4006 properties = []; 4007 } 4008 if (arg) 4009 mergeArgs.push(arg); 4010 }; 4011 const analyzePatchFlag = ({ key, value }) => { 4012 if (isStaticExp(key)) { 4013 const name = key.content; 4014 const isEventHandler = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isOn)(name); 4015 if (isEventHandler && 4016 (!isComponent || isDynamicComponent) && 4017 // omit the flag for click handlers because hydration gives click 4018 // dedicated fast path. 4019 name.toLowerCase() !== 'onclick' && 4020 // omit v-model handlers 4021 name !== 'onUpdate:modelValue' && 4022 // omit onVnodeXXX hooks 4023 !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isReservedProp)(name)) { 4024 hasHydrationEventBinding = true; 4025 } 4026 if (isEventHandler && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isReservedProp)(name)) { 4027 hasVnodeHook = true; 4028 } 4029 if (value.type === 20 /* NodeTypes.JS_CACHE_EXPRESSION */ || 4030 ((value.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ || 4031 value.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */) && 4032 getConstantType(value, context) > 0)) { 4033 // skip if the prop is a cached handler or has constant value 4034 return; 4035 } 4036 if (name === 'ref') { 4037 hasRef = true; 4038 } 4039 else if (name === 'class') { 4040 hasClassBinding = true; 4041 } 4042 else if (name === 'style') { 4043 hasStyleBinding = true; 4044 } 4045 else if (name !== 'key' && !dynamicPropNames.includes(name)) { 4046 dynamicPropNames.push(name); 4047 } 4048 // treat the dynamic class and style binding of the component as dynamic props 4049 if (isComponent && 4050 (name === 'class' || name === 'style') && 4051 !dynamicPropNames.includes(name)) { 4052 dynamicPropNames.push(name); 4053 } 4054 } 4055 else { 4056 hasDynamicKeys = true; 4057 } 4058 }; 4059 for (let i = 0; i < props.length; i++) { 4060 // static attribute 4061 const prop = props[i]; 4062 if (prop.type === 6 /* NodeTypes.ATTRIBUTE */) { 4063 const { loc, name, value } = prop; 4064 let isStatic = true; 4065 if (name === 'ref') { 4066 hasRef = true; 4067 if (context.scopes.vFor > 0) { 4068 properties.push(createObjectProperty(createSimpleExpression('ref_for', true), createSimpleExpression('true'))); 4069 } 4070 } 4071 // skip is on <component>, or is="vue:xxx" 4072 if (name === 'is' && 4073 (isComponentTag(tag) || 4074 (value && value.content.startsWith('vue:')) || 4075 (isCompatEnabled("COMPILER_IS_ON_ELEMENT" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */, context)))) { 4076 continue; 4077 } 4078 properties.push(createObjectProperty(createSimpleExpression(name, true, getInnerRange(loc, 0, name.length)), createSimpleExpression(value ? value.content : '', isStatic, value ? value.loc : loc))); 4079 } 4080 else { 4081 // directives 4082 const { name, arg, exp, loc } = prop; 4083 const isVBind = name === 'bind'; 4084 const isVOn = name === 'on'; 4085 // skip v-slot - it is handled by its dedicated transform. 4086 if (name === 'slot') { 4087 if (!isComponent) { 4088 context.onError(createCompilerError(40 /* ErrorCodes.X_V_SLOT_MISPLACED */, loc)); 4089 } 4090 continue; 4091 } 4092 // skip v-once/v-memo - they are handled by dedicated transforms. 4093 if (name === 'once' || name === 'memo') { 4094 continue; 4095 } 4096 // skip v-is and :is on <component> 4097 if (name === 'is' || 4098 (isVBind && 4099 isStaticArgOf(arg, 'is') && 4100 (isComponentTag(tag) || 4101 (isCompatEnabled("COMPILER_IS_ON_ELEMENT" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */, context))))) { 4102 continue; 4103 } 4104 // skip v-on in SSR compilation 4105 if (isVOn && ssr) { 4106 continue; 4107 } 4108 if ( 4109 // #938: elements with dynamic keys should be forced into blocks 4110 (isVBind && isStaticArgOf(arg, 'key')) || 4111 // inline before-update hooks need to force block so that it is invoked 4112 // before children 4113 (isVOn && hasChildren && isStaticArgOf(arg, 'vue:before-update'))) { 4114 shouldUseBlock = true; 4115 } 4116 if (isVBind && isStaticArgOf(arg, 'ref') && context.scopes.vFor > 0) { 4117 properties.push(createObjectProperty(createSimpleExpression('ref_for', true), createSimpleExpression('true'))); 4118 } 4119 // special case for v-bind and v-on with no argument 4120 if (!arg && (isVBind || isVOn)) { 4121 hasDynamicKeys = true; 4122 if (exp) { 4123 if (isVBind) { 4124 // have to merge early for compat build check 4125 pushMergeArg(); 4126 { 4127 // 2.x v-bind object order compat 4128 if ((true)) { 4129 const hasOverridableKeys = mergeArgs.some(arg => { 4130 if (arg.type === 15 /* NodeTypes.JS_OBJECT_EXPRESSION */) { 4131 return arg.properties.some(({ key }) => { 4132 if (key.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */ || 4133 !key.isStatic) { 4134 return true; 4135 } 4136 return (key.content !== 'class' && 4137 key.content !== 'style' && 4138 !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isOn)(key.content)); 4139 }); 4140 } 4141 else { 4142 // dynamic expression 4143 return true; 4144 } 4145 }); 4146 if (hasOverridableKeys) { 4147 checkCompatEnabled("COMPILER_V_BIND_OBJECT_ORDER" /* CompilerDeprecationTypes.COMPILER_V_BIND_OBJECT_ORDER */, context, loc); 4148 } 4149 } 4150 if (isCompatEnabled("COMPILER_V_BIND_OBJECT_ORDER" /* CompilerDeprecationTypes.COMPILER_V_BIND_OBJECT_ORDER */, context)) { 4151 mergeArgs.unshift(exp); 4152 continue; 4153 } 4154 } 4155 mergeArgs.push(exp); 4156 } 4157 else { 4158 // v-on="obj" -> toHandlers(obj) 4159 pushMergeArg({ 4160 type: 14 /* NodeTypes.JS_CALL_EXPRESSION */, 4161 loc, 4162 callee: context.helper(TO_HANDLERS), 4163 arguments: isComponent ? [exp] : [exp, `true`] 4164 }); 4165 } 4166 } 4167 else { 4168 context.onError(createCompilerError(isVBind 4169 ? 34 /* ErrorCodes.X_V_BIND_NO_EXPRESSION */ 4170 : 35 /* ErrorCodes.X_V_ON_NO_EXPRESSION */, loc)); 4171 } 4172 continue; 4173 } 4174 const directiveTransform = context.directiveTransforms[name]; 4175 if (directiveTransform) { 4176 // has built-in directive transform. 4177 const { props, needRuntime } = directiveTransform(prop, node, context); 4178 !ssr && props.forEach(analyzePatchFlag); 4179 if (isVOn && arg && !isStaticExp(arg)) { 4180 pushMergeArg(createObjectExpression(props, elementLoc)); 4181 } 4182 else { 4183 properties.push(...props); 4184 } 4185 if (needRuntime) { 4186 runtimeDirectives.push(prop); 4187 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(needRuntime)) { 4188 directiveImportMap.set(prop, needRuntime); 4189 } 4190 } 4191 } 4192 else if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isBuiltInDirective)(name)) { 4193 // no built-in transform, this is a user custom directive. 4194 runtimeDirectives.push(prop); 4195 // custom dirs may use beforeUpdate so they need to force blocks 4196 // to ensure before-update gets called before children update 4197 if (hasChildren) { 4198 shouldUseBlock = true; 4199 } 4200 } 4201 } 4202 } 4203 let propsExpression = undefined; 4204 // has v-bind="object" or v-on="object", wrap with mergeProps 4205 if (mergeArgs.length) { 4206 // close up any not-yet-merged props 4207 pushMergeArg(); 4208 if (mergeArgs.length > 1) { 4209 propsExpression = createCallExpression(context.helper(MERGE_PROPS), mergeArgs, elementLoc); 4210 } 4211 else { 4212 // single v-bind with nothing else - no need for a mergeProps call 4213 propsExpression = mergeArgs[0]; 4214 } 4215 } 4216 else if (properties.length) { 4217 propsExpression = createObjectExpression(dedupeProperties(properties), elementLoc); 4218 } 4219 // patchFlag analysis 4220 if (hasDynamicKeys) { 4221 patchFlag |= 16 /* PatchFlags.FULL_PROPS */; 4222 } 4223 else { 4224 if (hasClassBinding && !isComponent) { 4225 patchFlag |= 2 /* PatchFlags.CLASS */; 4226 } 4227 if (hasStyleBinding && !isComponent) { 4228 patchFlag |= 4 /* PatchFlags.STYLE */; 4229 } 4230 if (dynamicPropNames.length) { 4231 patchFlag |= 8 /* PatchFlags.PROPS */; 4232 } 4233 if (hasHydrationEventBinding) { 4234 patchFlag |= 32 /* PatchFlags.HYDRATE_EVENTS */; 4235 } 4236 } 4237 if (!shouldUseBlock && 4238 (patchFlag === 0 || patchFlag === 32 /* PatchFlags.HYDRATE_EVENTS */) && 4239 (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) { 4240 patchFlag |= 512 /* PatchFlags.NEED_PATCH */; 4241 } 4242 // pre-normalize props, SSR is skipped for now 4243 if (!context.inSSR && propsExpression) { 4244 switch (propsExpression.type) { 4245 case 15 /* NodeTypes.JS_OBJECT_EXPRESSION */: 4246 // means that there is no v-bind, 4247 // but still need to deal with dynamic key binding 4248 let classKeyIndex = -1; 4249 let styleKeyIndex = -1; 4250 let hasDynamicKey = false; 4251 for (let i = 0; i < propsExpression.properties.length; i++) { 4252 const key = propsExpression.properties[i].key; 4253 if (isStaticExp(key)) { 4254 if (key.content === 'class') { 4255 classKeyIndex = i; 4256 } 4257 else if (key.content === 'style') { 4258 styleKeyIndex = i; 4259 } 4260 } 4261 else if (!key.isHandlerKey) { 4262 hasDynamicKey = true; 4263 } 4264 } 4265 const classProp = propsExpression.properties[classKeyIndex]; 4266 const styleProp = propsExpression.properties[styleKeyIndex]; 4267 // no dynamic key 4268 if (!hasDynamicKey) { 4269 if (classProp && !isStaticExp(classProp.value)) { 4270 classProp.value = createCallExpression(context.helper(NORMALIZE_CLASS), [classProp.value]); 4271 } 4272 if (styleProp && 4273 // the static style is compiled into an object, 4274 // so use `hasStyleBinding` to ensure that it is a dynamic style binding 4275 (hasStyleBinding || 4276 (styleProp.value.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && 4277 styleProp.value.content.trim()[0] === `[`) || 4278 // v-bind:style and style both exist, 4279 // v-bind:style with static literal object 4280 styleProp.value.type === 17 /* NodeTypes.JS_ARRAY_EXPRESSION */)) { 4281 styleProp.value = createCallExpression(context.helper(NORMALIZE_STYLE), [styleProp.value]); 4282 } 4283 } 4284 else { 4285 // dynamic key binding, wrap with `normalizeProps` 4286 propsExpression = createCallExpression(context.helper(NORMALIZE_PROPS), [propsExpression]); 4287 } 4288 break; 4289 case 14 /* NodeTypes.JS_CALL_EXPRESSION */: 4290 // mergeProps call, do nothing 4291 break; 4292 default: 4293 // single v-bind 4294 propsExpression = createCallExpression(context.helper(NORMALIZE_PROPS), [ 4295 createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [ 4296 propsExpression 4297 ]) 4298 ]); 4299 break; 4300 } 4301 } 4302 return { 4303 props: propsExpression, 4304 directives: runtimeDirectives, 4305 patchFlag, 4306 dynamicPropNames, 4307 shouldUseBlock 4308 }; 4309} 4310// Dedupe props in an object literal. 4311// Literal duplicated attributes would have been warned during the parse phase, 4312// however, it's possible to encounter duplicated `onXXX` handlers with different 4313// modifiers. We also need to merge static and dynamic class / style attributes. 4314// - onXXX handlers / style: merge into array 4315// - class: merge into single expression with concatenation 4316function dedupeProperties(properties) { 4317 const knownProps = new Map(); 4318 const deduped = []; 4319 for (let i = 0; i < properties.length; i++) { 4320 const prop = properties[i]; 4321 // dynamic keys are always allowed 4322 if (prop.key.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */ || !prop.key.isStatic) { 4323 deduped.push(prop); 4324 continue; 4325 } 4326 const name = prop.key.content; 4327 const existing = knownProps.get(name); 4328 if (existing) { 4329 if (name === 'style' || name === 'class' || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isOn)(name)) { 4330 mergeAsArray(existing, prop); 4331 } 4332 // unexpected duplicate, should have emitted error during parse 4333 } 4334 else { 4335 knownProps.set(name, prop); 4336 deduped.push(prop); 4337 } 4338 } 4339 return deduped; 4340} 4341function mergeAsArray(existing, incoming) { 4342 if (existing.value.type === 17 /* NodeTypes.JS_ARRAY_EXPRESSION */) { 4343 existing.value.elements.push(incoming.value); 4344 } 4345 else { 4346 existing.value = createArrayExpression([existing.value, incoming.value], existing.loc); 4347 } 4348} 4349function buildDirectiveArgs(dir, context) { 4350 const dirArgs = []; 4351 const runtime = directiveImportMap.get(dir); 4352 if (runtime) { 4353 // built-in directive with runtime 4354 dirArgs.push(context.helperString(runtime)); 4355 } 4356 else { 4357 { 4358 // inject statement for resolving directive 4359 context.helper(RESOLVE_DIRECTIVE); 4360 context.directives.add(dir.name); 4361 dirArgs.push(toValidAssetId(dir.name, `directive`)); 4362 } 4363 } 4364 const { loc } = dir; 4365 if (dir.exp) 4366 dirArgs.push(dir.exp); 4367 if (dir.arg) { 4368 if (!dir.exp) { 4369 dirArgs.push(`void 0`); 4370 } 4371 dirArgs.push(dir.arg); 4372 } 4373 if (Object.keys(dir.modifiers).length) { 4374 if (!dir.arg) { 4375 if (!dir.exp) { 4376 dirArgs.push(`void 0`); 4377 } 4378 dirArgs.push(`void 0`); 4379 } 4380 const trueExpression = createSimpleExpression(`true`, false, loc); 4381 dirArgs.push(createObjectExpression(dir.modifiers.map(modifier => createObjectProperty(modifier, trueExpression)), loc)); 4382 } 4383 return createArrayExpression(dirArgs, dir.loc); 4384} 4385function stringifyDynamicPropNames(props) { 4386 let propsNamesString = `[`; 4387 for (let i = 0, l = props.length; i < l; i++) { 4388 propsNamesString += JSON.stringify(props[i]); 4389 if (i < l - 1) 4390 propsNamesString += ', '; 4391 } 4392 return propsNamesString + `]`; 4393} 4394function isComponentTag(tag) { 4395 return tag === 'component' || tag === 'Component'; 4396} 4397 4398( true) 4399 ? Object.freeze({}) 4400 : 0; 4401( true) ? Object.freeze([]) : 0; 4402const cacheStringFunction = (fn) => { 4403 const cache = Object.create(null); 4404 return ((str) => { 4405 const hit = cache[str]; 4406 return hit || (cache[str] = fn(str)); 4407 }); 4408}; 4409const camelizeRE = /-(\w)/g; 4410/** 4411 * @private 4412 */ 4413const camelize = cacheStringFunction((str) => { 4414 return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : '')); 4415}); 4416 4417const transformSlotOutlet = (node, context) => { 4418 if (isSlotOutlet(node)) { 4419 const { children, loc } = node; 4420 const { slotName, slotProps } = processSlotOutlet(node, context); 4421 const slotArgs = [ 4422 context.prefixIdentifiers ? `_ctx.$slots` : `$slots`, 4423 slotName, 4424 '{}', 4425 'undefined', 4426 'true' 4427 ]; 4428 let expectedLen = 2; 4429 if (slotProps) { 4430 slotArgs[2] = slotProps; 4431 expectedLen = 3; 4432 } 4433 if (children.length) { 4434 slotArgs[3] = createFunctionExpression([], children, false, false, loc); 4435 expectedLen = 4; 4436 } 4437 if (context.scopeId && !context.slotted) { 4438 expectedLen = 5; 4439 } 4440 slotArgs.splice(expectedLen); // remove unused arguments 4441 node.codegenNode = createCallExpression(context.helper(RENDER_SLOT), slotArgs, loc); 4442 } 4443}; 4444function processSlotOutlet(node, context) { 4445 let slotName = `"default"`; 4446 let slotProps = undefined; 4447 const nonNameProps = []; 4448 for (let i = 0; i < node.props.length; i++) { 4449 const p = node.props[i]; 4450 if (p.type === 6 /* NodeTypes.ATTRIBUTE */) { 4451 if (p.value) { 4452 if (p.name === 'name') { 4453 slotName = JSON.stringify(p.value.content); 4454 } 4455 else { 4456 p.name = camelize(p.name); 4457 nonNameProps.push(p); 4458 } 4459 } 4460 } 4461 else { 4462 if (p.name === 'bind' && isStaticArgOf(p.arg, 'name')) { 4463 if (p.exp) 4464 slotName = p.exp; 4465 } 4466 else { 4467 if (p.name === 'bind' && p.arg && isStaticExp(p.arg)) { 4468 p.arg.content = camelize(p.arg.content); 4469 } 4470 nonNameProps.push(p); 4471 } 4472 } 4473 } 4474 if (nonNameProps.length > 0) { 4475 const { props, directives } = buildProps(node, context, nonNameProps, false, false); 4476 slotProps = props; 4477 if (directives.length) { 4478 context.onError(createCompilerError(36 /* ErrorCodes.X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */, directives[0].loc)); 4479 } 4480 } 4481 return { 4482 slotName, 4483 slotProps 4484 }; 4485} 4486 4487const fnExpRE = /^\s*([\w$_]+|(async\s*)?\([^)]*?\))\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/; 4488const transformOn = (dir, node, context, augmentor) => { 4489 const { loc, modifiers, arg } = dir; 4490 if (!dir.exp && !modifiers.length) { 4491 context.onError(createCompilerError(35 /* ErrorCodes.X_V_ON_NO_EXPRESSION */, loc)); 4492 } 4493 let eventName; 4494 if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 4495 if (arg.isStatic) { 4496 let rawName = arg.content; 4497 // TODO deprecate @vnodeXXX usage 4498 if (rawName.startsWith('vue:')) { 4499 rawName = `vnode-${rawName.slice(4)}`; 4500 } 4501 const eventString = node.tagType !== 0 /* ElementTypes.ELEMENT */ || 4502 rawName.startsWith('vnode') || 4503 !/[A-Z]/.test(rawName) 4504 ? // for non-element and vnode lifecycle event listeners, auto convert 4505 // it to camelCase. See issue #2249 4506 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(rawName)) 4507 : // preserve case for plain element listeners that have uppercase 4508 // letters, as these may be custom elements' custom events 4509 `on:${rawName}`; 4510 eventName = createSimpleExpression(eventString, true, arg.loc); 4511 } 4512 else { 4513 // #2388 4514 eventName = createCompoundExpression([ 4515 `${context.helperString(TO_HANDLER_KEY)}(`, 4516 arg, 4517 `)` 4518 ]); 4519 } 4520 } 4521 else { 4522 // already a compound expression. 4523 eventName = arg; 4524 eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`); 4525 eventName.children.push(`)`); 4526 } 4527 // handler processing 4528 let exp = dir.exp; 4529 if (exp && !exp.content.trim()) { 4530 exp = undefined; 4531 } 4532 let shouldCache = context.cacheHandlers && !exp && !context.inVOnce; 4533 if (exp) { 4534 const isMemberExp = isMemberExpression(exp.content); 4535 const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content)); 4536 const hasMultipleStatements = exp.content.includes(`;`); 4537 if (true) { 4538 validateBrowserExpression(exp, context, false, hasMultipleStatements); 4539 } 4540 if (isInlineStatement || (shouldCache && isMemberExp)) { 4541 // wrap inline statement in a function expression 4542 exp = createCompoundExpression([ 4543 `${isInlineStatement 4544 ? `$event` 4545 : `${``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`, 4546 exp, 4547 hasMultipleStatements ? `}` : `)` 4548 ]); 4549 } 4550 } 4551 let ret = { 4552 props: [ 4553 createObjectProperty(eventName, exp || createSimpleExpression(`() => {}`, false, loc)) 4554 ] 4555 }; 4556 // apply extended compiler augmentor 4557 if (augmentor) { 4558 ret = augmentor(ret); 4559 } 4560 if (shouldCache) { 4561 // cache handlers so that it's always the same handler being passed down. 4562 // this avoids unnecessary re-renders when users use inline handlers on 4563 // components. 4564 ret.props[0].value = context.cache(ret.props[0].value); 4565 } 4566 // mark the key as handler for props normalization check 4567 ret.props.forEach(p => (p.key.isHandlerKey = true)); 4568 return ret; 4569}; 4570 4571// v-bind without arg is handled directly in ./transformElements.ts due to it affecting 4572// codegen for the entire props object. This transform here is only for v-bind 4573// *with* args. 4574const transformBind = (dir, _node, context) => { 4575 const { exp, modifiers, loc } = dir; 4576 const arg = dir.arg; 4577 if (arg.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 4578 arg.children.unshift(`(`); 4579 arg.children.push(`) || ""`); 4580 } 4581 else if (!arg.isStatic) { 4582 arg.content = `${arg.content} || ""`; 4583 } 4584 // .sync is replaced by v-model:arg 4585 if (modifiers.includes('camel')) { 4586 if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 4587 if (arg.isStatic) { 4588 arg.content = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(arg.content); 4589 } 4590 else { 4591 arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`; 4592 } 4593 } 4594 else { 4595 arg.children.unshift(`${context.helperString(CAMELIZE)}(`); 4596 arg.children.push(`)`); 4597 } 4598 } 4599 if (!context.inSSR) { 4600 if (modifiers.includes('prop')) { 4601 injectPrefix(arg, '.'); 4602 } 4603 if (modifiers.includes('attr')) { 4604 injectPrefix(arg, '^'); 4605 } 4606 } 4607 if (!exp || 4608 (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && !exp.content.trim())) { 4609 context.onError(createCompilerError(34 /* ErrorCodes.X_V_BIND_NO_EXPRESSION */, loc)); 4610 return { 4611 props: [createObjectProperty(arg, createSimpleExpression('', true, loc))] 4612 }; 4613 } 4614 return { 4615 props: [createObjectProperty(arg, exp)] 4616 }; 4617}; 4618const injectPrefix = (arg, prefix) => { 4619 if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 4620 if (arg.isStatic) { 4621 arg.content = prefix + arg.content; 4622 } 4623 else { 4624 arg.content = `\`${prefix}\${${arg.content}}\``; 4625 } 4626 } 4627 else { 4628 arg.children.unshift(`'${prefix}' + (`); 4629 arg.children.push(`)`); 4630 } 4631}; 4632 4633// Merge adjacent text nodes and expressions into a single expression 4634// e.g. <div>abc {{ d }} {{ e }}</div> should have a single expression node as child. 4635const transformText = (node, context) => { 4636 if (node.type === 0 /* NodeTypes.ROOT */ || 4637 node.type === 1 /* NodeTypes.ELEMENT */ || 4638 node.type === 11 /* NodeTypes.FOR */ || 4639 node.type === 10 /* NodeTypes.IF_BRANCH */) { 4640 // perform the transform on node exit so that all expressions have already 4641 // been processed. 4642 return () => { 4643 const children = node.children; 4644 let currentContainer = undefined; 4645 let hasText = false; 4646 for (let i = 0; i < children.length; i++) { 4647 const child = children[i]; 4648 if (isText(child)) { 4649 hasText = true; 4650 for (let j = i + 1; j < children.length; j++) { 4651 const next = children[j]; 4652 if (isText(next)) { 4653 if (!currentContainer) { 4654 currentContainer = children[i] = createCompoundExpression([child], child.loc); 4655 } 4656 // merge adjacent text node into current 4657 currentContainer.children.push(` + `, next); 4658 children.splice(j, 1); 4659 j--; 4660 } 4661 else { 4662 currentContainer = undefined; 4663 break; 4664 } 4665 } 4666 } 4667 } 4668 if (!hasText || 4669 // if this is a plain element with a single text child, leave it 4670 // as-is since the runtime has dedicated fast path for this by directly 4671 // setting textContent of the element. 4672 // for component root it's always normalized anyway. 4673 (children.length === 1 && 4674 (node.type === 0 /* NodeTypes.ROOT */ || 4675 (node.type === 1 /* NodeTypes.ELEMENT */ && 4676 node.tagType === 0 /* ElementTypes.ELEMENT */ && 4677 // #3756 4678 // custom directives can potentially add DOM elements arbitrarily, 4679 // we need to avoid setting textContent of the element at runtime 4680 // to avoid accidentally overwriting the DOM elements added 4681 // by the user through custom directives. 4682 !node.props.find(p => p.type === 7 /* NodeTypes.DIRECTIVE */ && 4683 !context.directiveTransforms[p.name]) && 4684 // in compat mode, <template> tags with no special directives 4685 // will be rendered as a fragment so its children must be 4686 // converted into vnodes. 4687 !(node.tag === 'template'))))) { 4688 return; 4689 } 4690 // pre-convert text nodes into createTextVNode(text) calls to avoid 4691 // runtime normalization. 4692 for (let i = 0; i < children.length; i++) { 4693 const child = children[i]; 4694 if (isText(child) || child.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */) { 4695 const callArgs = []; 4696 // createTextVNode defaults to single whitespace, so if it is a 4697 // single space the code could be an empty call to save bytes. 4698 if (child.type !== 2 /* NodeTypes.TEXT */ || child.content !== ' ') { 4699 callArgs.push(child); 4700 } 4701 // mark dynamic text with flag so it gets patched inside a block 4702 if (!context.ssr && 4703 getConstantType(child, context) === 0 /* ConstantTypes.NOT_CONSTANT */) { 4704 callArgs.push(1 /* PatchFlags.TEXT */ + 4705 (( true) ? ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[1]} */` : 0)); 4706 } 4707 children[i] = { 4708 type: 12 /* NodeTypes.TEXT_CALL */, 4709 content: child, 4710 loc: child.loc, 4711 codegenNode: createCallExpression(context.helper(CREATE_TEXT), callArgs) 4712 }; 4713 } 4714 } 4715 }; 4716 } 4717}; 4718 4719const seen = new WeakSet(); 4720const transformOnce = (node, context) => { 4721 if (node.type === 1 /* NodeTypes.ELEMENT */ && findDir(node, 'once', true)) { 4722 if (seen.has(node) || context.inVOnce) { 4723 return; 4724 } 4725 seen.add(node); 4726 context.inVOnce = true; 4727 context.helper(SET_BLOCK_TRACKING); 4728 return () => { 4729 context.inVOnce = false; 4730 const cur = context.currentNode; 4731 if (cur.codegenNode) { 4732 cur.codegenNode = context.cache(cur.codegenNode, true /* isVNode */); 4733 } 4734 }; 4735 } 4736}; 4737 4738const transformModel = (dir, node, context) => { 4739 const { exp, arg } = dir; 4740 if (!exp) { 4741 context.onError(createCompilerError(41 /* ErrorCodes.X_V_MODEL_NO_EXPRESSION */, dir.loc)); 4742 return createTransformProps(); 4743 } 4744 const rawExp = exp.loc.source; 4745 const expString = exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ ? exp.content : rawExp; 4746 // im SFC <script setup> inline mode, the exp may have been transformed into 4747 // _unref(exp) 4748 const bindingType = context.bindingMetadata[rawExp]; 4749 // check props 4750 if (bindingType === "props" /* BindingTypes.PROPS */ || 4751 bindingType === "props-aliased" /* BindingTypes.PROPS_ALIASED */) { 4752 context.onError(createCompilerError(44 /* ErrorCodes.X_V_MODEL_ON_PROPS */, exp.loc)); 4753 return createTransformProps(); 4754 } 4755 const maybeRef = !true ; 4756 if (!expString.trim() || 4757 (!isMemberExpression(expString) && !maybeRef)) { 4758 context.onError(createCompilerError(42 /* ErrorCodes.X_V_MODEL_MALFORMED_EXPRESSION */, exp.loc)); 4759 return createTransformProps(); 4760 } 4761 const propName = arg ? arg : createSimpleExpression('modelValue', true); 4762 const eventName = arg 4763 ? isStaticExp(arg) 4764 ? `onUpdate:${arg.content}` 4765 : createCompoundExpression(['"onUpdate:" + ', arg]) 4766 : `onUpdate:modelValue`; 4767 let assignmentExp; 4768 const eventArg = context.isTS ? `($event: any)` : `$event`; 4769 { 4770 assignmentExp = createCompoundExpression([ 4771 `${eventArg} => ((`, 4772 exp, 4773 `) = $event)` 4774 ]); 4775 } 4776 const props = [ 4777 // modelValue: foo 4778 createObjectProperty(propName, dir.exp), 4779 // "onUpdate:modelValue": $event => (foo = $event) 4780 createObjectProperty(eventName, assignmentExp) 4781 ]; 4782 // modelModifiers: { foo: true, "bar-baz": true } 4783 if (dir.modifiers.length && node.tagType === 1 /* ElementTypes.COMPONENT */) { 4784 const modifiers = dir.modifiers 4785 .map(m => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`) 4786 .join(`, `); 4787 const modifiersKey = arg 4788 ? isStaticExp(arg) 4789 ? `${arg.content}Modifiers` 4790 : createCompoundExpression([arg, ' + "Modifiers"']) 4791 : `modelModifiers`; 4792 props.push(createObjectProperty(modifiersKey, createSimpleExpression(`{ ${modifiers} }`, false, dir.loc, 2 /* ConstantTypes.CAN_HOIST */))); 4793 } 4794 return createTransformProps(props); 4795}; 4796function createTransformProps(props = []) { 4797 return { props }; 4798} 4799 4800const validDivisionCharRE = /[\w).+\-_$\]]/; 4801const transformFilter = (node, context) => { 4802 if (!isCompatEnabled("COMPILER_FILTER" /* CompilerDeprecationTypes.COMPILER_FILTERS */, context)) { 4803 return; 4804 } 4805 if (node.type === 5 /* NodeTypes.INTERPOLATION */) { 4806 // filter rewrite is applied before expression transform so only 4807 // simple expressions are possible at this stage 4808 rewriteFilter(node.content, context); 4809 } 4810 if (node.type === 1 /* NodeTypes.ELEMENT */) { 4811 node.props.forEach((prop) => { 4812 if (prop.type === 7 /* NodeTypes.DIRECTIVE */ && 4813 prop.name !== 'for' && 4814 prop.exp) { 4815 rewriteFilter(prop.exp, context); 4816 } 4817 }); 4818 } 4819}; 4820function rewriteFilter(node, context) { 4821 if (node.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 4822 parseFilter(node, context); 4823 } 4824 else { 4825 for (let i = 0; i < node.children.length; i++) { 4826 const child = node.children[i]; 4827 if (typeof child !== 'object') 4828 continue; 4829 if (child.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) { 4830 parseFilter(child, context); 4831 } 4832 else if (child.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */) { 4833 rewriteFilter(node, context); 4834 } 4835 else if (child.type === 5 /* NodeTypes.INTERPOLATION */) { 4836 rewriteFilter(child.content, context); 4837 } 4838 } 4839 } 4840} 4841function parseFilter(node, context) { 4842 const exp = node.content; 4843 let inSingle = false; 4844 let inDouble = false; 4845 let inTemplateString = false; 4846 let inRegex = false; 4847 let curly = 0; 4848 let square = 0; 4849 let paren = 0; 4850 let lastFilterIndex = 0; 4851 let c, prev, i, expression, filters = []; 4852 for (i = 0; i < exp.length; i++) { 4853 prev = c; 4854 c = exp.charCodeAt(i); 4855 if (inSingle) { 4856 if (c === 0x27 && prev !== 0x5c) 4857 inSingle = false; 4858 } 4859 else if (inDouble) { 4860 if (c === 0x22 && prev !== 0x5c) 4861 inDouble = false; 4862 } 4863 else if (inTemplateString) { 4864 if (c === 0x60 && prev !== 0x5c) 4865 inTemplateString = false; 4866 } 4867 else if (inRegex) { 4868 if (c === 0x2f && prev !== 0x5c) 4869 inRegex = false; 4870 } 4871 else if (c === 0x7c && // pipe 4872 exp.charCodeAt(i + 1) !== 0x7c && 4873 exp.charCodeAt(i - 1) !== 0x7c && 4874 !curly && 4875 !square && 4876 !paren) { 4877 if (expression === undefined) { 4878 // first filter, end of expression 4879 lastFilterIndex = i + 1; 4880 expression = exp.slice(0, i).trim(); 4881 } 4882 else { 4883 pushFilter(); 4884 } 4885 } 4886 else { 4887 switch (c) { 4888 case 0x22: 4889 inDouble = true; 4890 break; // " 4891 case 0x27: 4892 inSingle = true; 4893 break; // ' 4894 case 0x60: 4895 inTemplateString = true; 4896 break; // ` 4897 case 0x28: 4898 paren++; 4899 break; // ( 4900 case 0x29: 4901 paren--; 4902 break; // ) 4903 case 0x5b: 4904 square++; 4905 break; // [ 4906 case 0x5d: 4907 square--; 4908 break; // ] 4909 case 0x7b: 4910 curly++; 4911 break; // { 4912 case 0x7d: 4913 curly--; 4914 break; // } 4915 } 4916 if (c === 0x2f) { 4917 // / 4918 let j = i - 1; 4919 let p; 4920 // find first non-whitespace prev char 4921 for (; j >= 0; j--) { 4922 p = exp.charAt(j); 4923 if (p !== ' ') 4924 break; 4925 } 4926 if (!p || !validDivisionCharRE.test(p)) { 4927 inRegex = true; 4928 } 4929 } 4930 } 4931 } 4932 if (expression === undefined) { 4933 expression = exp.slice(0, i).trim(); 4934 } 4935 else if (lastFilterIndex !== 0) { 4936 pushFilter(); 4937 } 4938 function pushFilter() { 4939 filters.push(exp.slice(lastFilterIndex, i).trim()); 4940 lastFilterIndex = i + 1; 4941 } 4942 if (filters.length) { 4943 ( true) && 4944 warnDeprecation("COMPILER_FILTER" /* CompilerDeprecationTypes.COMPILER_FILTERS */, context, node.loc); 4945 for (i = 0; i < filters.length; i++) { 4946 expression = wrapFilter(expression, filters[i], context); 4947 } 4948 node.content = expression; 4949 } 4950} 4951function wrapFilter(exp, filter, context) { 4952 context.helper(RESOLVE_FILTER); 4953 const i = filter.indexOf('('); 4954 if (i < 0) { 4955 context.filters.add(filter); 4956 return `${toValidAssetId(filter, 'filter')}(${exp})`; 4957 } 4958 else { 4959 const name = filter.slice(0, i); 4960 const args = filter.slice(i + 1); 4961 context.filters.add(name); 4962 return `${toValidAssetId(name, 'filter')}(${exp}${args !== ')' ? ',' + args : args}`; 4963 } 4964} 4965 4966const seen$1 = new WeakSet(); 4967const transformMemo = (node, context) => { 4968 if (node.type === 1 /* NodeTypes.ELEMENT */) { 4969 const dir = findDir(node, 'memo'); 4970 if (!dir || seen$1.has(node)) { 4971 return; 4972 } 4973 seen$1.add(node); 4974 return () => { 4975 const codegenNode = node.codegenNode || 4976 context.currentNode.codegenNode; 4977 if (codegenNode && codegenNode.type === 13 /* NodeTypes.VNODE_CALL */) { 4978 // non-component sub tree should be turned into a block 4979 if (node.tagType !== 1 /* ElementTypes.COMPONENT */) { 4980 makeBlock(codegenNode, context); 4981 } 4982 node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [ 4983 dir.exp, 4984 createFunctionExpression(undefined, codegenNode), 4985 `_cache`, 4986 String(context.cached++) 4987 ]); 4988 } 4989 }; 4990 } 4991}; 4992 4993function getBaseTransformPreset(prefixIdentifiers) { 4994 return [ 4995 [ 4996 transformOnce, 4997 transformIf, 4998 transformMemo, 4999 transformFor, 5000 ...([transformFilter] ), 5001 ...(( true) 5002 ? [transformExpression] 5003 : 0), 5004 transformSlotOutlet, 5005 transformElement, 5006 trackSlotScopes, 5007 transformText 5008 ], 5009 { 5010 on: transformOn, 5011 bind: transformBind, 5012 model: transformModel 5013 } 5014 ]; 5015} 5016// we name it `baseCompile` so that higher order compilers like 5017// @vue/compiler-dom can export `compile` while re-exporting everything else. 5018function baseCompile(template, options = {}) { 5019 const onError = options.onError || defaultOnError; 5020 const isModuleMode = options.mode === 'module'; 5021 /* istanbul ignore if */ 5022 { 5023 if (options.prefixIdentifiers === true) { 5024 onError(createCompilerError(47 /* ErrorCodes.X_PREFIX_ID_NOT_SUPPORTED */)); 5025 } 5026 else if (isModuleMode) { 5027 onError(createCompilerError(48 /* ErrorCodes.X_MODULE_MODE_NOT_SUPPORTED */)); 5028 } 5029 } 5030 const prefixIdentifiers = !true ; 5031 if (options.cacheHandlers) { 5032 onError(createCompilerError(49 /* ErrorCodes.X_CACHE_HANDLER_NOT_SUPPORTED */)); 5033 } 5034 if (options.scopeId && !isModuleMode) { 5035 onError(createCompilerError(50 /* ErrorCodes.X_SCOPE_ID_NOT_SUPPORTED */)); 5036 } 5037 const ast = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(template) ? baseParse(template, options) : template; 5038 const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(); 5039 transform(ast, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, options, { 5040 prefixIdentifiers, 5041 nodeTransforms: [ 5042 ...nodeTransforms, 5043 ...(options.nodeTransforms || []) // user transforms 5044 ], 5045 directiveTransforms: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, directiveTransforms, options.directiveTransforms || {} // user transforms 5046 ) 5047 })); 5048 return generate(ast, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, options, { 5049 prefixIdentifiers 5050 })); 5051} 5052 5053const noopDirectiveTransform = () => ({ props: [] }); 5054 5055 5056 5057 5058/***/ }), 5059
vendor: 43,124 bytes, lines 5060-5701
5060/***/ "./node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js": 5061/*!*************************************************************************!*\ 5062 !*** ./node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js ***! 5063 \*************************************************************************/ 5064/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 5065 5066"use strict"; 5067__webpack_require__.r(__webpack_exports__); 5068/* harmony export */ __webpack_require__.d(__webpack_exports__, { 5069/* harmony export */ "BASE_TRANSITION": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.BASE_TRANSITION; }, 5070/* harmony export */ "CAMELIZE": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CAMELIZE; }, 5071/* harmony export */ "CAPITALIZE": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CAPITALIZE; }, 5072/* harmony export */ "CREATE_BLOCK": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_BLOCK; }, 5073/* harmony export */ "CREATE_COMMENT": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_COMMENT; }, 5074/* harmony export */ "CREATE_ELEMENT_BLOCK": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_ELEMENT_BLOCK; }, 5075/* harmony export */ "CREATE_ELEMENT_VNODE": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_ELEMENT_VNODE; }, 5076/* harmony export */ "CREATE_SLOTS": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_SLOTS; }, 5077/* harmony export */ "CREATE_STATIC": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_STATIC; }, 5078/* harmony export */ "CREATE_TEXT": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_TEXT; }, 5079/* harmony export */ "CREATE_VNODE": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_VNODE; }, 5080/* harmony export */ "DOMDirectiveTransforms": function() { return /* binding */ DOMDirectiveTransforms; }, 5081/* harmony export */ "DOMNodeTransforms": function() { return /* binding */ DOMNodeTransforms; }, 5082/* harmony export */ "FRAGMENT": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.FRAGMENT; }, 5083/* harmony export */ "GUARD_REACTIVE_PROPS": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.GUARD_REACTIVE_PROPS; }, 5084/* harmony export */ "IS_MEMO_SAME": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.IS_MEMO_SAME; }, 5085/* harmony export */ "IS_REF": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.IS_REF; }, 5086/* harmony export */ "KEEP_ALIVE": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.KEEP_ALIVE; }, 5087/* harmony export */ "MERGE_PROPS": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.MERGE_PROPS; }, 5088/* harmony export */ "NORMALIZE_CLASS": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NORMALIZE_CLASS; }, 5089/* harmony export */ "NORMALIZE_PROPS": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NORMALIZE_PROPS; }, 5090/* harmony export */ "NORMALIZE_STYLE": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NORMALIZE_STYLE; }, 5091/* harmony export */ "OPEN_BLOCK": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.OPEN_BLOCK; }, 5092/* harmony export */ "POP_SCOPE_ID": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.POP_SCOPE_ID; }, 5093/* harmony export */ "PUSH_SCOPE_ID": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.PUSH_SCOPE_ID; }, 5094/* harmony export */ "RENDER_LIST": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RENDER_LIST; }, 5095/* harmony export */ "RENDER_SLOT": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RENDER_SLOT; }, 5096/* harmony export */ "RESOLVE_COMPONENT": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_COMPONENT; }, 5097/* harmony export */ "RESOLVE_DIRECTIVE": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_DIRECTIVE; }, 5098/* harmony export */ "RESOLVE_DYNAMIC_COMPONENT": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_DYNAMIC_COMPONENT; }, 5099/* harmony export */ "RESOLVE_FILTER": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_FILTER; }, 5100/* harmony export */ "SET_BLOCK_TRACKING": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.SET_BLOCK_TRACKING; }, 5101/* harmony export */ "SUSPENSE": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.SUSPENSE; }, 5102/* harmony export */ "TELEPORT": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TELEPORT; }, 5103/* harmony export */ "TO_DISPLAY_STRING": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_DISPLAY_STRING; }, 5104/* harmony export */ "TO_HANDLERS": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_HANDLERS; }, 5105/* harmony export */ "TO_HANDLER_KEY": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_HANDLER_KEY; }, 5106/* harmony export */ "TRANSITION": function() { return /* binding */ TRANSITION; }, 5107/* harmony export */ "TRANSITION_GROUP": function() { return /* binding */ TRANSITION_GROUP; }, 5108/* harmony export */ "UNREF": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.UNREF; }, 5109/* harmony export */ "V_MODEL_CHECKBOX": function() { return /* binding */ V_MODEL_CHECKBOX; }, 5110/* harmony export */ "V_MODEL_DYNAMIC": function() { return /* binding */ V_MODEL_DYNAMIC; }, 5111/* harmony export */ "V_MODEL_RADIO": function() { return /* binding */ V_MODEL_RADIO; }, 5112/* harmony export */ "V_MODEL_SELECT": function() { return /* binding */ V_MODEL_SELECT; }, 5113/* harmony export */ "V_MODEL_TEXT": function() { return /* binding */ V_MODEL_TEXT; }, 5114/* harmony export */ "V_ON_WITH_KEYS": function() { return /* binding */ V_ON_WITH_KEYS; }, 5115/* harmony export */ "V_ON_WITH_MODIFIERS": function() { return /* binding */ V_ON_WITH_MODIFIERS; }, 5116/* harmony export */ "V_SHOW": function() { return /* binding */ V_SHOW; }, 5117/* harmony export */ "WITH_CTX": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.WITH_CTX; }, 5118/* harmony export */ "WITH_DIRECTIVES": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.WITH_DIRECTIVES; }, 5119/* harmony export */ "WITH_MEMO": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.WITH_MEMO; }, 5120/* harmony export */ "advancePositionWithClone": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.advancePositionWithClone; }, 5121/* harmony export */ "advancePositionWithMutation": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.advancePositionWithMutation; }, 5122/* harmony export */ "assert": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.assert; }, 5123/* harmony export */ "baseCompile": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseCompile; }, 5124/* harmony export */ "baseParse": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseParse; }, 5125/* harmony export */ "buildDirectiveArgs": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.buildDirectiveArgs; }, 5126/* harmony export */ "buildProps": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.buildProps; }, 5127/* harmony export */ "buildSlots": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.buildSlots; }, 5128/* harmony export */ "checkCompatEnabled": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.checkCompatEnabled; }, 5129/* harmony export */ "compile": function() { return /* binding */ compile; }, 5130/* harmony export */ "createArrayExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createArrayExpression; }, 5131/* harmony export */ "createAssignmentExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createAssignmentExpression; }, 5132/* harmony export */ "createBlockStatement": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createBlockStatement; }, 5133/* harmony export */ "createCacheExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCacheExpression; }, 5134/* harmony export */ "createCallExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression; }, 5135/* harmony export */ "createCompilerError": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompilerError; }, 5136/* harmony export */ "createCompoundExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompoundExpression; }, 5137/* harmony export */ "createConditionalExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createConditionalExpression; }, 5138/* harmony export */ "createDOMCompilerError": function() { return /* binding */ createDOMCompilerError; }, 5139/* harmony export */ "createForLoopParams": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createForLoopParams; }, 5140/* harmony export */ "createFunctionExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createFunctionExpression; }, 5141/* harmony export */ "createIfStatement": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createIfStatement; }, 5142/* harmony export */ "createInterpolation": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createInterpolation; }, 5143/* harmony export */ "createObjectExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectExpression; }, 5144/* harmony export */ "createObjectProperty": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty; }, 5145/* harmony export */ "createReturnStatement": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createReturnStatement; }, 5146/* harmony export */ "createRoot": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createRoot; }, 5147/* harmony export */ "createSequenceExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSequenceExpression; }, 5148/* harmony export */ "createSimpleExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression; }, 5149/* harmony export */ "createStructuralDirectiveTransform": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createStructuralDirectiveTransform; }, 5150/* harmony export */ "createTemplateLiteral": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createTemplateLiteral; }, 5151/* harmony export */ "createTransformContext": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createTransformContext; }, 5152/* harmony export */ "createVNodeCall": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createVNodeCall; }, 5153/* harmony export */ "extractIdentifiers": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.extractIdentifiers; }, 5154/* harmony export */ "findDir": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findDir; }, 5155/* harmony export */ "findProp": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findProp; }, 5156/* harmony export */ "generate": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.generate; }, 5157/* harmony export */ "generateCodeFrame": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.generateCodeFrame; }, 5158/* harmony export */ "getBaseTransformPreset": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getBaseTransformPreset; }, 5159/* harmony export */ "getConstantType": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getConstantType; }, 5160/* harmony export */ "getInnerRange": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getInnerRange; }, 5161/* harmony export */ "getMemoedVNodeCall": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getMemoedVNodeCall; }, 5162/* harmony export */ "getVNodeBlockHelper": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getVNodeBlockHelper; }, 5163/* harmony export */ "getVNodeHelper": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getVNodeHelper; }, 5164/* harmony export */ "hasDynamicKeyVBind": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.hasDynamicKeyVBind; }, 5165/* harmony export */ "hasScopeRef": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.hasScopeRef; }, 5166/* harmony export */ "helperNameMap": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.helperNameMap; }, 5167/* harmony export */ "injectProp": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.injectProp; }, 5168/* harmony export */ "isBuiltInType": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isBuiltInType; }, 5169/* harmony export */ "isCoreComponent": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isCoreComponent; }, 5170/* harmony export */ "isFunctionType": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isFunctionType; }, 5171/* harmony export */ "isInDestructureAssignment": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isInDestructureAssignment; }, 5172/* harmony export */ "isMemberExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isMemberExpression; }, 5173/* harmony export */ "isMemberExpressionBrowser": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isMemberExpressionBrowser; }, 5174/* harmony export */ "isMemberExpressionNode": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isMemberExpressionNode; }, 5175/* harmony export */ "isReferencedIdentifier": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isReferencedIdentifier; }, 5176/* harmony export */ "isSimpleIdentifier": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isSimpleIdentifier; }, 5177/* harmony export */ "isSlotOutlet": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isSlotOutlet; }, 5178/* harmony export */ "isStaticArgOf": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticArgOf; }, 5179/* harmony export */ "isStaticExp": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp; }, 5180/* harmony export */ "isStaticProperty": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticProperty; }, 5181/* harmony export */ "isStaticPropertyKey": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticPropertyKey; }, 5182/* harmony export */ "isTemplateNode": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isTemplateNode; }, 5183/* harmony export */ "isText": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isText; }, 5184/* harmony export */ "isVSlot": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isVSlot; }, 5185/* harmony export */ "locStub": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.locStub; }, 5186/* harmony export */ "makeBlock": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.makeBlock; }, 5187/* harmony export */ "noopDirectiveTransform": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.noopDirectiveTransform; }, 5188/* harmony export */ "parse": function() { return /* binding */ parse; }, 5189/* harmony export */ "parserOptions": function() { return /* binding */ parserOptions; }, 5190/* harmony export */ "processExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processExpression; }, 5191/* harmony export */ "processFor": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processFor; }, 5192/* harmony export */ "processIf": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processIf; }, 5193/* harmony export */ "processSlotOutlet": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processSlotOutlet; }, 5194/* harmony export */ "registerRuntimeHelpers": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeHelpers; }, 5195/* harmony export */ "resolveComponentType": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.resolveComponentType; }, 5196/* harmony export */ "stringifyExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.stringifyExpression; }, 5197/* harmony export */ "toValidAssetId": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.toValidAssetId; }, 5198/* harmony export */ "trackSlotScopes": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.trackSlotScopes; }, 5199/* harmony export */ "trackVForSlotScopes": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.trackVForSlotScopes; }, 5200/* harmony export */ "transform": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transform; }, 5201/* harmony export */ "transformBind": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformBind; }, 5202/* harmony export */ "transformElement": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformElement; }, 5203/* harmony export */ "transformExpression": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformExpression; }, 5204/* harmony export */ "transformModel": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformModel; }, 5205/* harmony export */ "transformOn": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformOn; }, 5206/* harmony export */ "transformStyle": function() { return /* binding */ transformStyle; }, 5207/* harmony export */ "traverseNode": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.traverseNode; }, 5208/* harmony export */ "walkBlockDeclarations": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.walkBlockDeclarations; }, 5209/* harmony export */ "walkFunctionParams": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.walkFunctionParams; }, 5210/* harmony export */ "walkIdentifiers": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.walkIdentifiers; }, 5211/* harmony export */ "warnDeprecation": function() { return /* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.warnDeprecation; } 5212/* harmony export */ }); 5213/* 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"); 5214/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 5215 5216 5217 5218 5219const V_MODEL_RADIO = Symbol(( true) ? `vModelRadio` : 0); 5220const V_MODEL_CHECKBOX = Symbol(( true) ? `vModelCheckbox` : 0); 5221const V_MODEL_TEXT = Symbol(( true) ? `vModelText` : 0); 5222const V_MODEL_SELECT = Symbol(( true) ? `vModelSelect` : 0); 5223const V_MODEL_DYNAMIC = Symbol(( true) ? `vModelDynamic` : 0); 5224const V_ON_WITH_MODIFIERS = Symbol(( true) ? `vOnModifiersGuard` : 0); 5225const V_ON_WITH_KEYS = Symbol(( true) ? `vOnKeysGuard` : 0); 5226const V_SHOW = Symbol(( true) ? `vShow` : 0); 5227const TRANSITION = Symbol(( true) ? `Transition` : 0); 5228const TRANSITION_GROUP = Symbol(( true) ? `TransitionGroup` : 0); 5229(0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeHelpers)({ 5230 [V_MODEL_RADIO]: `vModelRadio`, 5231 [V_MODEL_CHECKBOX]: `vModelCheckbox`, 5232 [V_MODEL_TEXT]: `vModelText`, 5233 [V_MODEL_SELECT]: `vModelSelect`, 5234 [V_MODEL_DYNAMIC]: `vModelDynamic`, 5235 [V_ON_WITH_MODIFIERS]: `withModifiers`, 5236 [V_ON_WITH_KEYS]: `withKeys`, 5237 [V_SHOW]: `vShow`, 5238 [TRANSITION]: `Transition`, 5239 [TRANSITION_GROUP]: `TransitionGroup` 5240}); 5241 5242/* eslint-disable no-restricted-globals */ 5243let decoder; 5244function decodeHtmlBrowser(raw, asAttr = false) { 5245 if (!decoder) { 5246 decoder = document.createElement('div'); 5247 } 5248 if (asAttr) { 5249 decoder.innerHTML = `<div foo="${raw.replace(/"/g, '"')}">`; 5250 return decoder.children[0].getAttribute('foo'); 5251 } 5252 else { 5253 decoder.innerHTML = raw; 5254 return decoder.textContent; 5255 } 5256} 5257 5258const isRawTextContainer = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)('style,iframe,script,noscript', true); 5259const parserOptions = { 5260 isVoidTag: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.isVoidTag, 5261 isNativeTag: tag => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isHTMLTag)(tag) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSVGTag)(tag), 5262 isPreTag: tag => tag === 'pre', 5263 decodeEntities: decodeHtmlBrowser , 5264 isBuiltInComponent: (tag) => { 5265 if ((0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isBuiltInType)(tag, `Transition`)) { 5266 return TRANSITION; 5267 } 5268 else if ((0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isBuiltInType)(tag, `TransitionGroup`)) { 5269 return TRANSITION_GROUP; 5270 } 5271 }, 5272 // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher 5273 getNamespace(tag, parent) { 5274 let ns = parent ? parent.ns : 0 /* DOMNamespaces.HTML */; 5275 if (parent && ns === 2 /* DOMNamespaces.MATH_ML */) { 5276 if (parent.tag === 'annotation-xml') { 5277 if (tag === 'svg') { 5278 return 1 /* DOMNamespaces.SVG */; 5279 } 5280 if (parent.props.some(a => a.type === 6 /* NodeTypes.ATTRIBUTE */ && 5281 a.name === 'encoding' && 5282 a.value != null && 5283 (a.value.content === 'text/html' || 5284 a.value.content === 'application/xhtml+xml'))) { 5285 ns = 0 /* DOMNamespaces.HTML */; 5286 } 5287 } 5288 else if (/^m(?:[ions]|text)$/.test(parent.tag) && 5289 tag !== 'mglyph' && 5290 tag !== 'malignmark') { 5291 ns = 0 /* DOMNamespaces.HTML */; 5292 } 5293 } 5294 else if (parent && ns === 1 /* DOMNamespaces.SVG */) { 5295 if (parent.tag === 'foreignObject' || 5296 parent.tag === 'desc' || 5297 parent.tag === 'title') { 5298 ns = 0 /* DOMNamespaces.HTML */; 5299 } 5300 } 5301 if (ns === 0 /* DOMNamespaces.HTML */) { 5302 if (tag === 'svg') { 5303 return 1 /* DOMNamespaces.SVG */; 5304 } 5305 if (tag === 'math') { 5306 return 2 /* DOMNamespaces.MATH_ML */; 5307 } 5308 } 5309 return ns; 5310 }, 5311 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments 5312 getTextMode({ tag, ns }) { 5313 if (ns === 0 /* DOMNamespaces.HTML */) { 5314 if (tag === 'textarea' || tag === 'title') { 5315 return 1 /* TextModes.RCDATA */; 5316 } 5317 if (isRawTextContainer(tag)) { 5318 return 2 /* TextModes.RAWTEXT */; 5319 } 5320 } 5321 return 0 /* TextModes.DATA */; 5322 } 5323}; 5324 5325// Parse inline CSS strings for static style attributes into an object. 5326// This is a NodeTransform since it works on the static `style` attribute and 5327// converts it into a dynamic equivalent: 5328// style="color: red" -> :style='{ "color": "red" }' 5329// It is then processed by `transformElement` and included in the generated 5330// props. 5331const transformStyle = node => { 5332 if (node.type === 1 /* NodeTypes.ELEMENT */) { 5333 node.props.forEach((p, i) => { 5334 if (p.type === 6 /* NodeTypes.ATTRIBUTE */ && p.name === 'style' && p.value) { 5335 // replace p with an expression node 5336 node.props[i] = { 5337 type: 7 /* NodeTypes.DIRECTIVE */, 5338 name: `bind`, 5339 arg: (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`style`, true, p.loc), 5340 exp: parseInlineCSS(p.value.content, p.loc), 5341 modifiers: [], 5342 loc: p.loc 5343 }; 5344 } 5345 }); 5346 } 5347}; 5348const parseInlineCSS = (cssText, loc) => { 5349 const normalized = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.parseStringStyle)(cssText); 5350 return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(JSON.stringify(normalized), false, loc, 3 /* ConstantTypes.CAN_STRINGIFY */); 5351}; 5352 5353function createDOMCompilerError(code, loc) { 5354 return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompilerError)(code, loc, true ? DOMErrorMessages : 0); 5355} 5356const DOMErrorMessages = { 5357 [51 /* DOMErrorCodes.X_V_HTML_NO_EXPRESSION */]: `v-html is missing expression.`, 5358 [52 /* DOMErrorCodes.X_V_HTML_WITH_CHILDREN */]: `v-html will override element children.`, 5359 [53 /* DOMErrorCodes.X_V_TEXT_NO_EXPRESSION */]: `v-text is missing expression.`, 5360 [54 /* DOMErrorCodes.X_V_TEXT_WITH_CHILDREN */]: `v-text will override element children.`, 5361 [55 /* DOMErrorCodes.X_V_MODEL_ON_INVALID_ELEMENT */]: `v-model can only be used on <input>, <textarea> and <select> elements.`, 5362 [56 /* DOMErrorCodes.X_V_MODEL_ARG_ON_ELEMENT */]: `v-model argument is not supported on plain elements.`, 5363 [57 /* DOMErrorCodes.X_V_MODEL_ON_FILE_INPUT_ELEMENT */]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`, 5364 [58 /* DOMErrorCodes.X_V_MODEL_UNNECESSARY_VALUE */]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`, 5365 [59 /* DOMErrorCodes.X_V_SHOW_NO_EXPRESSION */]: `v-show is missing expression.`, 5366 [60 /* DOMErrorCodes.X_TRANSITION_INVALID_CHILDREN */]: `<Transition> expects exactly one child element or component.`, 5367 [61 /* DOMErrorCodes.X_IGNORED_SIDE_EFFECT_TAG */]: `Tags with side effect (<script> and <style>) are ignored in client component templates.` 5368}; 5369 5370const transformVHtml = (dir, node, context) => { 5371 const { exp, loc } = dir; 5372 if (!exp) { 5373 context.onError(createDOMCompilerError(51 /* DOMErrorCodes.X_V_HTML_NO_EXPRESSION */, loc)); 5374 } 5375 if (node.children.length) { 5376 context.onError(createDOMCompilerError(52 /* DOMErrorCodes.X_V_HTML_WITH_CHILDREN */, loc)); 5377 node.children.length = 0; 5378 } 5379 return { 5380 props: [ 5381 (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty)((0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`innerHTML`, true, loc), exp || (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)('', true)) 5382 ] 5383 }; 5384}; 5385 5386const transformVText = (dir, node, context) => { 5387 const { exp, loc } = dir; 5388 if (!exp) { 5389 context.onError(createDOMCompilerError(53 /* DOMErrorCodes.X_V_TEXT_NO_EXPRESSION */, loc)); 5390 } 5391 if (node.children.length) { 5392 context.onError(createDOMCompilerError(54 /* DOMErrorCodes.X_V_TEXT_WITH_CHILDREN */, loc)); 5393 node.children.length = 0; 5394 } 5395 return { 5396 props: [ 5397 (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty)((0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`textContent`, true), exp 5398 ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getConstantType)(exp, context) > 0 5399 ? exp 5400 : (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression)(context.helperString(_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_DISPLAY_STRING), [exp], loc) 5401 : (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)('', true)) 5402 ] 5403 }; 5404}; 5405 5406const transformModel = (dir, node, context) => { 5407 const baseResult = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformModel)(dir, node, context); 5408 // base transform has errors OR component v-model (only need props) 5409 if (!baseResult.props.length || node.tagType === 1 /* ElementTypes.COMPONENT */) { 5410 return baseResult; 5411 } 5412 if (dir.arg) { 5413 context.onError(createDOMCompilerError(56 /* DOMErrorCodes.X_V_MODEL_ARG_ON_ELEMENT */, dir.arg.loc)); 5414 } 5415 function checkDuplicatedValue() { 5416 const value = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findProp)(node, 'value'); 5417 if (value) { 5418 context.onError(createDOMCompilerError(58 /* DOMErrorCodes.X_V_MODEL_UNNECESSARY_VALUE */, value.loc)); 5419 } 5420 } 5421 const { tag } = node; 5422 const isCustomElement = context.isCustomElement(tag); 5423 if (tag === 'input' || 5424 tag === 'textarea' || 5425 tag === 'select' || 5426 isCustomElement) { 5427 let directiveToUse = V_MODEL_TEXT; 5428 let isInvalidType = false; 5429 if (tag === 'input' || isCustomElement) { 5430 const type = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findProp)(node, `type`); 5431 if (type) { 5432 if (type.type === 7 /* NodeTypes.DIRECTIVE */) { 5433 // :type="foo" 5434 directiveToUse = V_MODEL_DYNAMIC; 5435 } 5436 else if (type.value) { 5437 switch (type.value.content) { 5438 case 'radio': 5439 directiveToUse = V_MODEL_RADIO; 5440 break; 5441 case 'checkbox': 5442 directiveToUse = V_MODEL_CHECKBOX; 5443 break; 5444 case 'file': 5445 isInvalidType = true; 5446 context.onError(createDOMCompilerError(57 /* DOMErrorCodes.X_V_MODEL_ON_FILE_INPUT_ELEMENT */, dir.loc)); 5447 break; 5448 default: 5449 // text type 5450 ( true) && checkDuplicatedValue(); 5451 break; 5452 } 5453 } 5454 } 5455 else if ((0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.hasDynamicKeyVBind)(node)) { 5456 // element has bindings with dynamic keys, which can possibly contain 5457 // "type". 5458 directiveToUse = V_MODEL_DYNAMIC; 5459 } 5460 else { 5461 // text type 5462 ( true) && checkDuplicatedValue(); 5463 } 5464 } 5465 else if (tag === 'select') { 5466 directiveToUse = V_MODEL_SELECT; 5467 } 5468 else { 5469 // textarea 5470 ( true) && checkDuplicatedValue(); 5471 } 5472 // inject runtime directive 5473 // by returning the helper symbol via needRuntime 5474 // the import will replaced a resolveDirective call. 5475 if (!isInvalidType) { 5476 baseResult.needRuntime = context.helper(directiveToUse); 5477 } 5478 } 5479 else { 5480 context.onError(createDOMCompilerError(55 /* DOMErrorCodes.X_V_MODEL_ON_INVALID_ELEMENT */, dir.loc)); 5481 } 5482 // native vmodel doesn't need the `modelValue` props since they are also 5483 // passed to the runtime as `binding.value`. removing it reduces code size. 5484 baseResult.props = baseResult.props.filter(p => !(p.key.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && 5485 p.key.content === 'modelValue')); 5486 return baseResult; 5487}; 5488 5489const isEventOptionModifier = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)(`passive,once,capture`); 5490const isNonKeyModifier = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)( 5491// event propagation management 5492`stop,prevent,self,` + 5493 // system modifiers + exact 5494 `ctrl,shift,alt,meta,exact,` + 5495 // mouse 5496 `middle`); 5497// left & right could be mouse or key modifiers based on event type 5498const maybeKeyModifier = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)('left,right'); 5499const isKeyboardEvent = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)(`onkeyup,onkeydown,onkeypress`, true); 5500const resolveModifiers = (key, modifiers, context, loc) => { 5501 const keyModifiers = []; 5502 const nonKeyModifiers = []; 5503 const eventOptionModifiers = []; 5504 for (let i = 0; i < modifiers.length; i++) { 5505 const modifier = modifiers[i]; 5506 if (modifier === 'native' && 5507 (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.checkCompatEnabled)("COMPILER_V_ON_NATIVE" /* CompilerDeprecationTypes.COMPILER_V_ON_NATIVE */, context, loc)) { 5508 eventOptionModifiers.push(modifier); 5509 } 5510 else if (isEventOptionModifier(modifier)) { 5511 // eventOptionModifiers: modifiers for addEventListener() options, 5512 // e.g. .passive & .capture 5513 eventOptionModifiers.push(modifier); 5514 } 5515 else { 5516 // runtimeModifiers: modifiers that needs runtime guards 5517 if (maybeKeyModifier(modifier)) { 5518 if ((0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key)) { 5519 if (isKeyboardEvent(key.content)) { 5520 keyModifiers.push(modifier); 5521 } 5522 else { 5523 nonKeyModifiers.push(modifier); 5524 } 5525 } 5526 else { 5527 keyModifiers.push(modifier); 5528 nonKeyModifiers.push(modifier); 5529 } 5530 } 5531 else { 5532 if (isNonKeyModifier(modifier)) { 5533 nonKeyModifiers.push(modifier); 5534 } 5535 else { 5536 keyModifiers.push(modifier); 5537 } 5538 } 5539 } 5540 } 5541 return { 5542 keyModifiers, 5543 nonKeyModifiers, 5544 eventOptionModifiers 5545 }; 5546}; 5547const transformClick = (key, event) => { 5548 const isStaticClick = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key) && key.content.toLowerCase() === 'onclick'; 5549 return isStaticClick 5550 ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(event, true) 5551 : key.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */ 5552 ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompoundExpression)([ 5553 `(`, 5554 key, 5555 `) === "onClick" ? "${event}" : (`, 5556 key, 5557 `)` 5558 ]) 5559 : key; 5560}; 5561const transformOn = (dir, node, context) => { 5562 return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformOn)(dir, node, context, baseResult => { 5563 const { modifiers } = dir; 5564 if (!modifiers.length) 5565 return baseResult; 5566 let { key, value: handlerExp } = baseResult.props[0]; 5567 const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc); 5568 // normalize click.right and click.middle since they don't actually fire 5569 if (nonKeyModifiers.includes('right')) { 5570 key = transformClick(key, `onContextmenu`); 5571 } 5572 if (nonKeyModifiers.includes('middle')) { 5573 key = transformClick(key, `onMouseup`); 5574 } 5575 if (nonKeyModifiers.length) { 5576 handlerExp = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression)(context.helper(V_ON_WITH_MODIFIERS), [ 5577 handlerExp, 5578 JSON.stringify(nonKeyModifiers) 5579 ]); 5580 } 5581 if (keyModifiers.length && 5582 // if event name is dynamic, always wrap with keys guard 5583 (!(0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key) || isKeyboardEvent(key.content))) { 5584 handlerExp = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression)(context.helper(V_ON_WITH_KEYS), [ 5585 handlerExp, 5586 JSON.stringify(keyModifiers) 5587 ]); 5588 } 5589 if (eventOptionModifiers.length) { 5590 const modifierPostfix = eventOptionModifiers.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize).join(''); 5591 key = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key) 5592 ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`${key.content}${modifierPostfix}`, true) 5593 : (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompoundExpression)([`(`, key, `) + "${modifierPostfix}"`]); 5594 } 5595 return { 5596 props: [(0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty)(key, handlerExp)] 5597 }; 5598 }); 5599}; 5600 5601const transformShow = (dir, node, context) => { 5602 const { exp, loc } = dir; 5603 if (!exp) { 5604 context.onError(createDOMCompilerError(59 /* DOMErrorCodes.X_V_SHOW_NO_EXPRESSION */, loc)); 5605 } 5606 return { 5607 props: [], 5608 needRuntime: context.helper(V_SHOW) 5609 }; 5610}; 5611 5612const transformTransition = (node, context) => { 5613 if (node.type === 1 /* NodeTypes.ELEMENT */ && 5614 node.tagType === 1 /* ElementTypes.COMPONENT */) { 5615 const component = context.isBuiltInComponent(node.tag); 5616 if (component === TRANSITION) { 5617 return () => { 5618 if (!node.children.length) { 5619 return; 5620 } 5621 // warn multiple transition children 5622 if (hasMultipleChildren(node)) { 5623 context.onError(createDOMCompilerError(60 /* DOMErrorCodes.X_TRANSITION_INVALID_CHILDREN */, { 5624 start: node.children[0].loc.start, 5625 end: node.children[node.children.length - 1].loc.end, 5626 source: '' 5627 })); 5628 } 5629 // check if it's s single child w/ v-show 5630 // if yes, inject "persisted: true" to the transition props 5631 const child = node.children[0]; 5632 if (child.type === 1 /* NodeTypes.ELEMENT */) { 5633 for (const p of child.props) { 5634 if (p.type === 7 /* NodeTypes.DIRECTIVE */ && p.name === 'show') { 5635 node.props.push({ 5636 type: 6 /* NodeTypes.ATTRIBUTE */, 5637 name: 'persisted', 5638 value: undefined, 5639 loc: node.loc 5640 }); 5641 } 5642 } 5643 } 5644 }; 5645 } 5646 } 5647}; 5648function hasMultipleChildren(node) { 5649 // #1352 filter out potential comment nodes. 5650 const children = (node.children = node.children.filter(c => c.type !== 3 /* NodeTypes.COMMENT */ && 5651 !(c.type === 2 /* NodeTypes.TEXT */ && !c.content.trim()))); 5652 const child = children[0]; 5653 return (children.length !== 1 || 5654 child.type === 11 /* NodeTypes.FOR */ || 5655 (child.type === 9 /* NodeTypes.IF */ && child.branches.some(hasMultipleChildren))); 5656} 5657 5658const ignoreSideEffectTags = (node, context) => { 5659 if (node.type === 1 /* NodeTypes.ELEMENT */ && 5660 node.tagType === 0 /* ElementTypes.ELEMENT */ && 5661 (node.tag === 'script' || node.tag === 'style')) { 5662 context.onError(createDOMCompilerError(61 /* DOMErrorCodes.X_IGNORED_SIDE_EFFECT_TAG */, node.loc)); 5663 context.removeNode(); 5664 } 5665}; 5666 5667const DOMNodeTransforms = [ 5668 transformStyle, 5669 ...(( true) ? [transformTransition] : 0) 5670]; 5671const DOMDirectiveTransforms = { 5672 cloak: _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.noopDirectiveTransform, 5673 html: transformVHtml, 5674 text: transformVText, 5675 model: transformModel, 5676 on: transformOn, 5677 show: transformShow 5678}; 5679function compile(template, options = {}) { 5680 return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseCompile)(template, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, parserOptions, options, { 5681 nodeTransforms: [ 5682 // ignore <script> and <tag> 5683 // this is not put inside DOMNodeTransforms because that list is used 5684 // by compiler-ssr to generate vnode fallback branches 5685 ignoreSideEffectTags, 5686 ...DOMNodeTransforms, 5687 ...(options.nodeTransforms || []) 5688 ], 5689 directiveTransforms: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, DOMDirectiveTransforms, options.directiveTransforms || {}), 5690 transformHoist: null 5691 })); 5692} 5693function parse(template, options = {}) { 5694 return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseParse)(template, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, parserOptions, options)); 5695} 5696 5697 5698 5699 5700/***/ }), 5701
vendor: 46,288 bytes, lines 5702-7000
5702/***/ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js": 5703/*!*********************************************************************!*\ 5704 !*** ./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js ***! 5705 \*********************************************************************/ 5706/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 5707 5708"use strict"; 5709__webpack_require__.r(__webpack_exports__); 5710/* harmony export */ __webpack_require__.d(__webpack_exports__, { 5711/* harmony export */ "EffectScope": function() { return /* binding */ EffectScope; }, 5712/* harmony export */ "ITERATE_KEY": function() { return /* binding */ ITERATE_KEY; }, 5713/* harmony export */ "ReactiveEffect": function() { return /* binding */ ReactiveEffect; }, 5714/* harmony export */ "computed": function() { return /* binding */ computed; }, 5715/* harmony export */ "customRef": function() { return /* binding */ customRef; }, 5716/* harmony export */ "deferredComputed": function() { return /* binding */ deferredComputed; }, 5717/* harmony export */ "effect": function() { return /* binding */ effect; }, 5718/* harmony export */ "effectScope": function() { return /* binding */ effectScope; }, 5719/* harmony export */ "enableTracking": function() { return /* binding */ enableTracking; }, 5720/* harmony export */ "getCurrentScope": function() { return /* binding */ getCurrentScope; }, 5721/* harmony export */ "isProxy": function() { return /* binding */ isProxy; }, 5722/* harmony export */ "isReactive": function() { return /* binding */ isReactive; }, 5723/* harmony export */ "isReadonly": function() { return /* binding */ isReadonly; }, 5724/* harmony export */ "isRef": function() { return /* binding */ isRef; }, 5725/* harmony export */ "isShallow": function() { return /* binding */ isShallow; }, 5726/* harmony export */ "markRaw": function() { return /* binding */ markRaw; }, 5727/* harmony export */ "onScopeDispose": function() { return /* binding */ onScopeDispose; }, 5728/* harmony export */ "pauseTracking": function() { return /* binding */ pauseTracking; }, 5729/* harmony export */ "proxyRefs": function() { return /* binding */ proxyRefs; }, 5730/* harmony export */ "reactive": function() { return /* binding */ reactive; }, 5731/* harmony export */ "readonly": function() { return /* binding */ readonly; }, 5732/* harmony export */ "ref": function() { return /* binding */ ref; }, 5733/* harmony export */ "resetTracking": function() { return /* binding */ resetTracking; }, 5734/* harmony export */ "shallowReactive": function() { return /* binding */ shallowReactive; }, 5735/* harmony export */ "shallowReadonly": function() { return /* binding */ shallowReadonly; }, 5736/* harmony export */ "shallowRef": function() { return /* binding */ shallowRef; }, 5737/* harmony export */ "stop": function() { return /* binding */ stop; }, 5738/* harmony export */ "toRaw": function() { return /* binding */ toRaw; }, 5739/* harmony export */ "toRef": function() { return /* binding */ toRef; }, 5740/* harmony export */ "toRefs": function() { return /* binding */ toRefs; }, 5741/* harmony export */ "track": function() { return /* binding */ track; }, 5742/* harmony export */ "trigger": function() { return /* binding */ trigger; }, 5743/* harmony export */ "triggerRef": function() { return /* binding */ triggerRef; }, 5744/* harmony export */ "unref": function() { return /* binding */ unref; } 5745/* harmony export */ }); 5746/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 5747 5748 5749function warn(msg, ...args) { 5750 console.warn(`[Vue warn] ${msg}`, ...args); 5751} 5752 5753let activeEffectScope; 5754class EffectScope { 5755 constructor(detached = false) { 5756 this.detached = detached; 5757 /** 5758 * @internal 5759 */ 5760 this.active = true; 5761 /** 5762 * @internal 5763 */ 5764 this.effects = []; 5765 /** 5766 * @internal 5767 */ 5768 this.cleanups = []; 5769 this.parent = activeEffectScope; 5770 if (!detached && activeEffectScope) { 5771 this.index = 5772 (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1; 5773 } 5774 } 5775 run(fn) { 5776 if (this.active) { 5777 const currentEffectScope = activeEffectScope; 5778 try { 5779 activeEffectScope = this; 5780 return fn(); 5781 } 5782 finally { 5783 activeEffectScope = currentEffectScope; 5784 } 5785 } 5786 else if ((true)) { 5787 warn(`cannot run an inactive effect scope.`); 5788 } 5789 } 5790 /** 5791 * This should only be called on non-detached scopes 5792 * @internal 5793 */ 5794 on() { 5795 activeEffectScope = this; 5796 } 5797 /** 5798 * This should only be called on non-detached scopes 5799 * @internal 5800 */ 5801 off() { 5802 activeEffectScope = this.parent; 5803 } 5804 stop(fromParent) { 5805 if (this.active) { 5806 let i, l; 5807 for (i = 0, l = this.effects.length; i < l; i++) { 5808 this.effects[i].stop(); 5809 } 5810 for (i = 0, l = this.cleanups.length; i < l; i++) { 5811 this.cleanups[i](); 5812 } 5813 if (this.scopes) { 5814 for (i = 0, l = this.scopes.length; i < l; i++) { 5815 this.scopes[i].stop(true); 5816 } 5817 } 5818 // nested scope, dereference from parent to avoid memory leaks 5819 if (!this.detached && this.parent && !fromParent) { 5820 // optimized O(1) removal 5821 const last = this.parent.scopes.pop(); 5822 if (last && last !== this) { 5823 this.parent.scopes[this.index] = last; 5824 last.index = this.index; 5825 } 5826 } 5827 this.parent = undefined; 5828 this.active = false; 5829 } 5830 } 5831} 5832function effectScope(detached) { 5833 return new EffectScope(detached); 5834} 5835function recordEffectScope(effect, scope = activeEffectScope) { 5836 if (scope && scope.active) { 5837 scope.effects.push(effect); 5838 } 5839} 5840function getCurrentScope() { 5841 return activeEffectScope; 5842} 5843function onScopeDispose(fn) { 5844 if (activeEffectScope) { 5845 activeEffectScope.cleanups.push(fn); 5846 } 5847 else if ((true)) { 5848 warn(`onScopeDispose() is called when there is no active effect scope` + 5849 ` to be associated with.`); 5850 } 5851} 5852 5853const createDep = (effects) => { 5854 const dep = new Set(effects); 5855 dep.w = 0; 5856 dep.n = 0; 5857 return dep; 5858}; 5859const wasTracked = (dep) => (dep.w & trackOpBit) > 0; 5860const newTracked = (dep) => (dep.n & trackOpBit) > 0; 5861const initDepMarkers = ({ deps }) => { 5862 if (deps.length) { 5863 for (let i = 0; i < deps.length; i++) { 5864 deps[i].w |= trackOpBit; // set was tracked 5865 } 5866 } 5867}; 5868const finalizeDepMarkers = (effect) => { 5869 const { deps } = effect; 5870 if (deps.length) { 5871 let ptr = 0; 5872 for (let i = 0; i < deps.length; i++) { 5873 const dep = deps[i]; 5874 if (wasTracked(dep) && !newTracked(dep)) { 5875 dep.delete(effect); 5876 } 5877 else { 5878 deps[ptr++] = dep; 5879 } 5880 // clear bits 5881 dep.w &= ~trackOpBit; 5882 dep.n &= ~trackOpBit; 5883 } 5884 deps.length = ptr; 5885 } 5886}; 5887 5888const targetMap = new WeakMap(); 5889// The number of effects currently being tracked recursively. 5890let effectTrackDepth = 0; 5891let trackOpBit = 1; 5892/** 5893 * The bitwise track markers support at most 30 levels of recursion. 5894 * This value is chosen to enable modern JS engines to use a SMI on all platforms. 5895 * When recursion depth is greater, fall back to using a full cleanup. 5896 */ 5897const maxMarkerBits = 30; 5898let activeEffect; 5899const ITERATE_KEY = Symbol(( true) ? 'iterate' : 0); 5900const MAP_KEY_ITERATE_KEY = Symbol(( true) ? 'Map key iterate' : 0); 5901class ReactiveEffect { 5902 constructor(fn, scheduler = null, scope) { 5903 this.fn = fn; 5904 this.scheduler = scheduler; 5905 this.active = true; 5906 this.deps = []; 5907 this.parent = undefined; 5908 recordEffectScope(this, scope); 5909 } 5910 run() { 5911 if (!this.active) { 5912 return this.fn(); 5913 } 5914 let parent = activeEffect; 5915 let lastShouldTrack = shouldTrack; 5916 while (parent) { 5917 if (parent === this) { 5918 return; 5919 } 5920 parent = parent.parent; 5921 } 5922 try { 5923 this.parent = activeEffect; 5924 activeEffect = this; 5925 shouldTrack = true; 5926 trackOpBit = 1 << ++effectTrackDepth; 5927 if (effectTrackDepth <= maxMarkerBits) { 5928 initDepMarkers(this); 5929 } 5930 else { 5931 cleanupEffect(this); 5932 } 5933 return this.fn(); 5934 } 5935 finally { 5936 if (effectTrackDepth <= maxMarkerBits) { 5937 finalizeDepMarkers(this); 5938 } 5939 trackOpBit = 1 << --effectTrackDepth; 5940 activeEffect = this.parent; 5941 shouldTrack = lastShouldTrack; 5942 this.parent = undefined; 5943 if (this.deferStop) { 5944 this.stop(); 5945 } 5946 } 5947 } 5948 stop() { 5949 // stopped while running itself - defer the cleanup 5950 if (activeEffect === this) { 5951 this.deferStop = true; 5952 } 5953 else if (this.active) { 5954 cleanupEffect(this); 5955 if (this.onStop) { 5956 this.onStop(); 5957 } 5958 this.active = false; 5959 } 5960 } 5961} 5962function cleanupEffect(effect) { 5963 const { deps } = effect; 5964 if (deps.length) { 5965 for (let i = 0; i < deps.length; i++) { 5966 deps[i].delete(effect); 5967 } 5968 deps.length = 0; 5969 } 5970} 5971function effect(fn, options) { 5972 if (fn.effect) { 5973 fn = fn.effect.fn; 5974 } 5975 const _effect = new ReactiveEffect(fn); 5976 if (options) { 5977 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)(_effect, options); 5978 if (options.scope) 5979 recordEffectScope(_effect, options.scope); 5980 } 5981 if (!options || !options.lazy) { 5982 _effect.run(); 5983 } 5984 const runner = _effect.run.bind(_effect); 5985 runner.effect = _effect; 5986 return runner; 5987} 5988function stop(runner) { 5989 runner.effect.stop(); 5990} 5991let shouldTrack = true; 5992const trackStack = []; 5993function pauseTracking() { 5994 trackStack.push(shouldTrack); 5995 shouldTrack = false; 5996} 5997function enableTracking() { 5998 trackStack.push(shouldTrack); 5999 shouldTrack = true; 6000} 6001function resetTracking() { 6002 const last = trackStack.pop(); 6003 shouldTrack = last === undefined ? true : last; 6004} 6005function track(target, type, key) { 6006 if (shouldTrack && activeEffect) { 6007 let depsMap = targetMap.get(target); 6008 if (!depsMap) { 6009 targetMap.set(target, (depsMap = new Map())); 6010 } 6011 let dep = depsMap.get(key); 6012 if (!dep) { 6013 depsMap.set(key, (dep = createDep())); 6014 } 6015 const eventInfo = ( true) 6016 ? { effect: activeEffect, target, type, key } 6017 : 0; 6018 trackEffects(dep, eventInfo); 6019 } 6020} 6021function trackEffects(dep, debuggerEventExtraInfo) { 6022 let shouldTrack = false; 6023 if (effectTrackDepth <= maxMarkerBits) { 6024 if (!newTracked(dep)) { 6025 dep.n |= trackOpBit; // set newly tracked 6026 shouldTrack = !wasTracked(dep); 6027 } 6028 } 6029 else { 6030 // Full cleanup mode. 6031 shouldTrack = !dep.has(activeEffect); 6032 } 6033 if (shouldTrack) { 6034 dep.add(activeEffect); 6035 activeEffect.deps.push(dep); 6036 if (( true) && activeEffect.onTrack) { 6037 activeEffect.onTrack(Object.assign({ effect: activeEffect }, debuggerEventExtraInfo)); 6038 } 6039 } 6040} 6041function trigger(target, type, key, newValue, oldValue, oldTarget) { 6042 const depsMap = targetMap.get(target); 6043 if (!depsMap) { 6044 // never been tracked 6045 return; 6046 } 6047 let deps = []; 6048 if (type === "clear" /* TriggerOpTypes.CLEAR */) { 6049 // collection being cleared 6050 // trigger all effects for target 6051 deps = [...depsMap.values()]; 6052 } 6053 else if (key === 'length' && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target)) { 6054 const newLength = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.toNumber)(newValue); 6055 depsMap.forEach((dep, key) => { 6056 if (key === 'length' || key >= newLength) { 6057 deps.push(dep); 6058 } 6059 }); 6060 } 6061 else { 6062 // schedule runs for SET | ADD | DELETE 6063 if (key !== void 0) { 6064 deps.push(depsMap.get(key)); 6065 } 6066 // also run for iteration key on ADD | DELETE | Map.SET 6067 switch (type) { 6068 case "add" /* TriggerOpTypes.ADD */: 6069 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target)) { 6070 deps.push(depsMap.get(ITERATE_KEY)); 6071 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target)) { 6072 deps.push(depsMap.get(MAP_KEY_ITERATE_KEY)); 6073 } 6074 } 6075 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isIntegerKey)(key)) { 6076 // new index added to array -> length changes 6077 deps.push(depsMap.get('length')); 6078 } 6079 break; 6080 case "delete" /* TriggerOpTypes.DELETE */: 6081 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target)) { 6082 deps.push(depsMap.get(ITERATE_KEY)); 6083 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target)) { 6084 deps.push(depsMap.get(MAP_KEY_ITERATE_KEY)); 6085 } 6086 } 6087 break; 6088 case "set" /* TriggerOpTypes.SET */: 6089 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target)) { 6090 deps.push(depsMap.get(ITERATE_KEY)); 6091 } 6092 break; 6093 } 6094 } 6095 const eventInfo = ( true) 6096 ? { target, type, key, newValue, oldValue, oldTarget } 6097 : 0; 6098 if (deps.length === 1) { 6099 if (deps[0]) { 6100 if ((true)) { 6101 triggerEffects(deps[0], eventInfo); 6102 } 6103 else {} 6104 } 6105 } 6106 else { 6107 const effects = []; 6108 for (const dep of deps) { 6109 if (dep) { 6110 effects.push(...dep); 6111 } 6112 } 6113 if ((true)) { 6114 triggerEffects(createDep(effects), eventInfo); 6115 } 6116 else {} 6117 } 6118} 6119function triggerEffects(dep, debuggerEventExtraInfo) { 6120 // spread into array for stabilization 6121 const effects = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(dep) ? dep : [...dep]; 6122 for (const effect of effects) { 6123 if (effect.computed) { 6124 triggerEffect(effect, debuggerEventExtraInfo); 6125 } 6126 } 6127 for (const effect of effects) { 6128 if (!effect.computed) { 6129 triggerEffect(effect, debuggerEventExtraInfo); 6130 } 6131 } 6132} 6133function triggerEffect(effect, debuggerEventExtraInfo) { 6134 if (effect !== activeEffect || effect.allowRecurse) { 6135 if (( true) && effect.onTrigger) { 6136 effect.onTrigger((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({ effect }, debuggerEventExtraInfo)); 6137 } 6138 if (effect.scheduler) { 6139 effect.scheduler(); 6140 } 6141 else { 6142 effect.run(); 6143 } 6144 } 6145} 6146 6147const isNonTrackableKeys = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.makeMap)(`__proto__,__v_isRef,__isVue`); 6148const builtInSymbols = new Set( 6149/*#__PURE__*/ 6150Object.getOwnPropertyNames(Symbol) 6151 // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller' 6152 // but accessing them on Symbol leads to TypeError because Symbol is a strict mode 6153 // function 6154 .filter(key => key !== 'arguments' && key !== 'caller') 6155 .map(key => Symbol[key]) 6156 .filter(_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)); 6157const get = /*#__PURE__*/ createGetter(); 6158const shallowGet = /*#__PURE__*/ createGetter(false, true); 6159const readonlyGet = /*#__PURE__*/ createGetter(true); 6160const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true); 6161const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations(); 6162function createArrayInstrumentations() { 6163 const instrumentations = {}; 6164 ['includes', 'indexOf', 'lastIndexOf'].forEach(key => { 6165 instrumentations[key] = function (...args) { 6166 const arr = toRaw(this); 6167 for (let i = 0, l = this.length; i < l; i++) { 6168 track(arr, "get" /* TrackOpTypes.GET */, i + ''); 6169 } 6170 // we run the method using the original args first (which may be reactive) 6171 const res = arr[key](...args); 6172 if (res === -1 || res === false) { 6173 // if that didn't work, run it again using raw values. 6174 return arr[key](...args.map(toRaw)); 6175 } 6176 else { 6177 return res; 6178 } 6179 }; 6180 }); 6181 ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => { 6182 instrumentations[key] = function (...args) { 6183 pauseTracking(); 6184 const res = toRaw(this)[key].apply(this, args); 6185 resetTracking(); 6186 return res; 6187 }; 6188 }); 6189 return instrumentations; 6190} 6191function createGetter(isReadonly = false, shallow = false) { 6192 return function get(target, key, receiver) { 6193 if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) { 6194 return !isReadonly; 6195 } 6196 else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) { 6197 return isReadonly; 6198 } 6199 else if (key === "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */) { 6200 return shallow; 6201 } 6202 else if (key === "__v_raw" /* ReactiveFlags.RAW */ && 6203 receiver === 6204 (isReadonly 6205 ? shallow 6206 ? shallowReadonlyMap 6207 : readonlyMap 6208 : shallow 6209 ? shallowReactiveMap 6210 : reactiveMap).get(target)) { 6211 return target; 6212 } 6213 const targetIsArray = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target); 6214 if (!isReadonly && targetIsArray && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(arrayInstrumentations, key)) { 6215 return Reflect.get(arrayInstrumentations, key, receiver); 6216 } 6217 const res = Reflect.get(target, key, receiver); 6218 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { 6219 return res; 6220 } 6221 if (!isReadonly) { 6222 track(target, "get" /* TrackOpTypes.GET */, key); 6223 } 6224 if (shallow) { 6225 return res; 6226 } 6227 if (isRef(res)) { 6228 // ref unwrapping - skip unwrap for Array + integer key. 6229 return targetIsArray && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isIntegerKey)(key) ? res : res.value; 6230 } 6231 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(res)) { 6232 // Convert returned value into a proxy as well. we do the isObject check 6233 // here to avoid invalid value warning. Also need to lazy access readonly 6234 // and reactive here to avoid circular dependency. 6235 return isReadonly ? readonly(res) : reactive(res); 6236 } 6237 return res; 6238 }; 6239} 6240const set = /*#__PURE__*/ createSetter(); 6241const shallowSet = /*#__PURE__*/ createSetter(true); 6242function createSetter(shallow = false) { 6243 return function set(target, key, value, receiver) { 6244 let oldValue = target[key]; 6245 if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) { 6246 return false; 6247 } 6248 if (!shallow) { 6249 if (!isShallow(value) && !isReadonly(value)) { 6250 oldValue = toRaw(oldValue); 6251 value = toRaw(value); 6252 } 6253 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target) && isRef(oldValue) && !isRef(value)) { 6254 oldValue.value = value; 6255 return true; 6256 } 6257 } 6258 const hadKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isIntegerKey)(key) 6259 ? Number(key) < target.length 6260 : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(target, key); 6261 const result = Reflect.set(target, key, value, receiver); 6262 // don't trigger if target is something up in the prototype chain of original 6263 if (target === toRaw(receiver)) { 6264 if (!hadKey) { 6265 trigger(target, "add" /* TriggerOpTypes.ADD */, key, value); 6266 } 6267 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(value, oldValue)) { 6268 trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue); 6269 } 6270 } 6271 return result; 6272 }; 6273} 6274function deleteProperty(target, key) { 6275 const hadKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(target, key); 6276 const oldValue = target[key]; 6277 const result = Reflect.deleteProperty(target, key); 6278 if (result && hadKey) { 6279 trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue); 6280 } 6281 return result; 6282} 6283function has(target, key) { 6284 const result = Reflect.has(target, key); 6285 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(key) || !builtInSymbols.has(key)) { 6286 track(target, "has" /* TrackOpTypes.HAS */, key); 6287 } 6288 return result; 6289} 6290function ownKeys(target) { 6291 track(target, "iterate" /* TrackOpTypes.ITERATE */, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target) ? 'length' : ITERATE_KEY); 6292 return Reflect.ownKeys(target); 6293} 6294const mutableHandlers = { 6295 get, 6296 set, 6297 deleteProperty, 6298 has, 6299 ownKeys 6300}; 6301const readonlyHandlers = { 6302 get: readonlyGet, 6303 set(target, key) { 6304 if ((true)) { 6305 warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target); 6306 } 6307 return true; 6308 }, 6309 deleteProperty(target, key) { 6310 if ((true)) { 6311 warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); 6312 } 6313 return true; 6314 } 6315}; 6316const shallowReactiveHandlers = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, mutableHandlers, { 6317 get: shallowGet, 6318 set: shallowSet 6319}); 6320// Props handlers are special in the sense that it should not unwrap top-level 6321// refs (in order to allow refs to be explicitly passed down), but should 6322// retain the reactivity of the normal readonly object. 6323const shallowReadonlyHandlers = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, readonlyHandlers, { 6324 get: shallowReadonlyGet 6325}); 6326 6327const toShallow = (value) => value; 6328const getProto = (v) => Reflect.getPrototypeOf(v); 6329function get$1(target, key, isReadonly = false, isShallow = false) { 6330 // #1772: readonly(reactive(Map)) should return readonly + reactive version 6331 // of the value 6332 target = target["__v_raw" /* ReactiveFlags.RAW */]; 6333 const rawTarget = toRaw(target); 6334 const rawKey = toRaw(key); 6335 if (!isReadonly) { 6336 if (key !== rawKey) { 6337 track(rawTarget, "get" /* TrackOpTypes.GET */, key); 6338 } 6339 track(rawTarget, "get" /* TrackOpTypes.GET */, rawKey); 6340 } 6341 const { has } = getProto(rawTarget); 6342 const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; 6343 if (has.call(rawTarget, key)) { 6344 return wrap(target.get(key)); 6345 } 6346 else if (has.call(rawTarget, rawKey)) { 6347 return wrap(target.get(rawKey)); 6348 } 6349 else if (target !== rawTarget) { 6350 // #3602 readonly(reactive(Map)) 6351 // ensure that the nested reactive `Map` can do tracking for itself 6352 target.get(key); 6353 } 6354} 6355function has$1(key, isReadonly = false) { 6356 const target = this["__v_raw" /* ReactiveFlags.RAW */]; 6357 const rawTarget = toRaw(target); 6358 const rawKey = toRaw(key); 6359 if (!isReadonly) { 6360 if (key !== rawKey) { 6361 track(rawTarget, "has" /* TrackOpTypes.HAS */, key); 6362 } 6363 track(rawTarget, "has" /* TrackOpTypes.HAS */, rawKey); 6364 } 6365 return key === rawKey 6366 ? target.has(key) 6367 : target.has(key) || target.has(rawKey); 6368} 6369function size(target, isReadonly = false) { 6370 target = target["__v_raw" /* ReactiveFlags.RAW */]; 6371 !isReadonly && track(toRaw(target), "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY); 6372 return Reflect.get(target, 'size', target); 6373} 6374function add(value) { 6375 value = toRaw(value); 6376 const target = toRaw(this); 6377 const proto = getProto(target); 6378 const hadKey = proto.has.call(target, value); 6379 if (!hadKey) { 6380 target.add(value); 6381 trigger(target, "add" /* TriggerOpTypes.ADD */, value, value); 6382 } 6383 return this; 6384} 6385function set$1(key, value) { 6386 value = toRaw(value); 6387 const target = toRaw(this); 6388 const { has, get } = getProto(target); 6389 let hadKey = has.call(target, key); 6390 if (!hadKey) { 6391 key = toRaw(key); 6392 hadKey = has.call(target, key); 6393 } 6394 else if ((true)) { 6395 checkIdentityKeys(target, has, key); 6396 } 6397 const oldValue = get.call(target, key); 6398 target.set(key, value); 6399 if (!hadKey) { 6400 trigger(target, "add" /* TriggerOpTypes.ADD */, key, value); 6401 } 6402 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(value, oldValue)) { 6403 trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue); 6404 } 6405 return this; 6406} 6407function deleteEntry(key) { 6408 const target = toRaw(this); 6409 const { has, get } = getProto(target); 6410 let hadKey = has.call(target, key); 6411 if (!hadKey) { 6412 key = toRaw(key); 6413 hadKey = has.call(target, key); 6414 } 6415 else if ((true)) { 6416 checkIdentityKeys(target, has, key); 6417 } 6418 const oldValue = get ? get.call(target, key) : undefined; 6419 // forward the operation before queueing reactions 6420 const result = target.delete(key); 6421 if (hadKey) { 6422 trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue); 6423 } 6424 return result; 6425} 6426function clear() { 6427 const target = toRaw(this); 6428 const hadItems = target.size !== 0; 6429 const oldTarget = ( true) 6430 ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target) 6431 ? new Map(target) 6432 : new Set(target) 6433 : 0; 6434 // forward the operation before queueing reactions 6435 const result = target.clear(); 6436 if (hadItems) { 6437 trigger(target, "clear" /* TriggerOpTypes.CLEAR */, undefined, undefined, oldTarget); 6438 } 6439 return result; 6440} 6441function createForEach(isReadonly, isShallow) { 6442 return function forEach(callback, thisArg) { 6443 const observed = this; 6444 const target = observed["__v_raw" /* ReactiveFlags.RAW */]; 6445 const rawTarget = toRaw(target); 6446 const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; 6447 !isReadonly && track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY); 6448 return target.forEach((value, key) => { 6449 // important: make sure the callback is 6450 // 1. invoked with the reactive map as `this` and 3rd arg 6451 // 2. the value received should be a corresponding reactive/readonly. 6452 return callback.call(thisArg, wrap(value), wrap(key), observed); 6453 }); 6454 }; 6455} 6456function createIterableMethod(method, isReadonly, isShallow) { 6457 return function (...args) { 6458 const target = this["__v_raw" /* ReactiveFlags.RAW */]; 6459 const rawTarget = toRaw(target); 6460 const targetIsMap = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(rawTarget); 6461 const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap); 6462 const isKeyOnly = method === 'keys' && targetIsMap; 6463 const innerIterator = target[method](...args); 6464 const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; 6465 !isReadonly && 6466 track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); 6467 // return a wrapped iterator which returns observed versions of the 6468 // values emitted from the real iterator 6469 return { 6470 // iterator protocol 6471 next() { 6472 const { value, done } = innerIterator.next(); 6473 return done 6474 ? { value, done } 6475 : { 6476 value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), 6477 done 6478 }; 6479 }, 6480 // iterable protocol 6481 [Symbol.iterator]() { 6482 return this; 6483 } 6484 }; 6485 }; 6486} 6487function createReadonlyMethod(type) { 6488 return function (...args) { 6489 if ((true)) { 6490 const key = args[0] ? `on key "${args[0]}" ` : ``; 6491 console.warn(`${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.capitalize)(type)} operation ${key}failed: target is readonly.`, toRaw(this)); 6492 } 6493 return type === "delete" /* TriggerOpTypes.DELETE */ ? false : this; 6494 }; 6495} 6496function createInstrumentations() { 6497 const mutableInstrumentations = { 6498 get(key) { 6499 return get$1(this, key); 6500 }, 6501 get size() { 6502 return size(this); 6503 }, 6504 has: has$1, 6505 add, 6506 set: set$1, 6507 delete: deleteEntry, 6508 clear, 6509 forEach: createForEach(false, false) 6510 }; 6511 const shallowInstrumentations = { 6512 get(key) { 6513 return get$1(this, key, false, true); 6514 }, 6515 get size() { 6516 return size(this); 6517 }, 6518 has: has$1, 6519 add, 6520 set: set$1, 6521 delete: deleteEntry, 6522 clear, 6523 forEach: createForEach(false, true) 6524 }; 6525 const readonlyInstrumentations = { 6526 get(key) { 6527 return get$1(this, key, true); 6528 }, 6529 get size() { 6530 return size(this, true); 6531 }, 6532 has(key) { 6533 return has$1.call(this, key, true); 6534 }, 6535 add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */), 6536 set: createReadonlyMethod("set" /* TriggerOpTypes.SET */), 6537 delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */), 6538 clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */), 6539 forEach: createForEach(true, false) 6540 }; 6541 const shallowReadonlyInstrumentations = { 6542 get(key) { 6543 return get$1(this, key, true, true); 6544 }, 6545 get size() { 6546 return size(this, true); 6547 }, 6548 has(key) { 6549 return has$1.call(this, key, true); 6550 }, 6551 add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */), 6552 set: createReadonlyMethod("set" /* TriggerOpTypes.SET */), 6553 delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */), 6554 clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */), 6555 forEach: createForEach(true, true) 6556 }; 6557 const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]; 6558 iteratorMethods.forEach(method => { 6559 mutableInstrumentations[method] = createIterableMethod(method, false, false); 6560 readonlyInstrumentations[method] = createIterableMethod(method, true, false); 6561 shallowInstrumentations[method] = createIterableMethod(method, false, true); 6562 shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true); 6563 }); 6564 return [ 6565 mutableInstrumentations, 6566 readonlyInstrumentations, 6567 shallowInstrumentations, 6568 shallowReadonlyInstrumentations 6569 ]; 6570} 6571const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations(); 6572function createInstrumentationGetter(isReadonly, shallow) { 6573 const instrumentations = shallow 6574 ? isReadonly 6575 ? shallowReadonlyInstrumentations 6576 : shallowInstrumentations 6577 : isReadonly 6578 ? readonlyInstrumentations 6579 : mutableInstrumentations; 6580 return (target, key, receiver) => { 6581 if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) { 6582 return !isReadonly; 6583 } 6584 else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) { 6585 return isReadonly; 6586 } 6587 else if (key === "__v_raw" /* ReactiveFlags.RAW */) { 6588 return target; 6589 } 6590 return Reflect.get((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(instrumentations, key) && key in target 6591 ? instrumentations 6592 : target, key, receiver); 6593 }; 6594} 6595const mutableCollectionHandlers = { 6596 get: /*#__PURE__*/ createInstrumentationGetter(false, false) 6597}; 6598const shallowCollectionHandlers = { 6599 get: /*#__PURE__*/ createInstrumentationGetter(false, true) 6600}; 6601const readonlyCollectionHandlers = { 6602 get: /*#__PURE__*/ createInstrumentationGetter(true, false) 6603}; 6604const shallowReadonlyCollectionHandlers = { 6605 get: /*#__PURE__*/ createInstrumentationGetter(true, true) 6606}; 6607function checkIdentityKeys(target, has, key) { 6608 const rawKey = toRaw(key); 6609 if (rawKey !== key && has.call(target, rawKey)) { 6610 const type = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.toRawType)(target); 6611 console.warn(`Reactive ${type} contains both the raw and reactive ` + 6612 `versions of the same object${type === `Map` ? ` as keys` : ``}, ` + 6613 `which can lead to inconsistencies. ` + 6614 `Avoid differentiating between the raw and reactive versions ` + 6615 `of an object and only use the reactive version if possible.`); 6616 } 6617} 6618 6619const reactiveMap = new WeakMap(); 6620const shallowReactiveMap = new WeakMap(); 6621const readonlyMap = new WeakMap(); 6622const shallowReadonlyMap = new WeakMap(); 6623function targetTypeMap(rawType) { 6624 switch (rawType) { 6625 case 'Object': 6626 case 'Array': 6627 return 1 /* TargetType.COMMON */; 6628 case 'Map': 6629 case 'Set': 6630 case 'WeakMap': 6631 case 'WeakSet': 6632 return 2 /* TargetType.COLLECTION */; 6633 default: 6634 return 0 /* TargetType.INVALID */; 6635 } 6636} 6637function getTargetType(value) { 6638 return value["__v_skip" /* ReactiveFlags.SKIP */] || !Object.isExtensible(value) 6639 ? 0 /* TargetType.INVALID */ 6640 : targetTypeMap((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.toRawType)(value)); 6641} 6642function reactive(target) { 6643 // if trying to observe a readonly proxy, return the readonly version. 6644 if (isReadonly(target)) { 6645 return target; 6646 } 6647 return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); 6648} 6649/** 6650 * Return a shallowly-reactive copy of the original object, where only the root 6651 * level properties are reactive. It also does not auto-unwrap refs (even at the 6652 * root level). 6653 */ 6654function shallowReactive(target) { 6655 return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); 6656} 6657/** 6658 * Creates a readonly copy of the original object. Note the returned copy is not 6659 * made reactive, but `readonly` can be called on an already reactive object. 6660 */ 6661function readonly(target) { 6662 return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); 6663} 6664/** 6665 * Returns a reactive-copy of the original object, where only the root level 6666 * properties are readonly, and does NOT unwrap refs nor recursively convert 6667 * returned properties. 6668 * This is used for creating the props proxy object for stateful components. 6669 */ 6670function shallowReadonly(target) { 6671 return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap); 6672} 6673function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) { 6674 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(target)) { 6675 if ((true)) { 6676 console.warn(`value cannot be made reactive: ${String(target)}`); 6677 } 6678 return target; 6679 } 6680 // target is already a Proxy, return it. 6681 // exception: calling readonly() on a reactive object 6682 if (target["__v_raw" /* ReactiveFlags.RAW */] && 6683 !(isReadonly && target["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */])) { 6684 return target; 6685 } 6686 // target already has corresponding Proxy 6687 const existingProxy = proxyMap.get(target); 6688 if (existingProxy) { 6689 return existingProxy; 6690 } 6691 // only specific value types can be observed. 6692 const targetType = getTargetType(target); 6693 if (targetType === 0 /* TargetType.INVALID */) { 6694 return target; 6695 } 6696 const proxy = new Proxy(target, targetType === 2 /* TargetType.COLLECTION */ ? collectionHandlers : baseHandlers); 6697 proxyMap.set(target, proxy); 6698 return proxy; 6699} 6700function isReactive(value) { 6701 if (isReadonly(value)) { 6702 return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]); 6703 } 6704 return !!(value && value["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */]); 6705} 6706function isReadonly(value) { 6707 return !!(value && value["__v_isReadonly" /* ReactiveFlags.IS_READONLY */]); 6708} 6709function isShallow(value) { 6710 return !!(value && value["__v_isShallow" /* ReactiveFlags.IS_SHALLOW */]); 6711} 6712function isProxy(value) { 6713 return isReactive(value) || isReadonly(value); 6714} 6715function toRaw(observed) { 6716 const raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */]; 6717 return raw ? toRaw(raw) : observed; 6718} 6719function markRaw(value) { 6720 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.def)(value, "__v_skip" /* ReactiveFlags.SKIP */, true); 6721 return value; 6722} 6723const toReactive = (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(value) ? reactive(value) : value; 6724const toReadonly = (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(value) ? readonly(value) : value; 6725 6726function trackRefValue(ref) { 6727 if (shouldTrack && activeEffect) { 6728 ref = toRaw(ref); 6729 if ((true)) { 6730 trackEffects(ref.dep || (ref.dep = createDep()), { 6731 target: ref, 6732 type: "get" /* TrackOpTypes.GET */, 6733 key: 'value' 6734 }); 6735 } 6736 else {} 6737 } 6738} 6739function triggerRefValue(ref, newVal) { 6740 ref = toRaw(ref); 6741 if (ref.dep) { 6742 if ((true)) { 6743 triggerEffects(ref.dep, { 6744 target: ref, 6745 type: "set" /* TriggerOpTypes.SET */, 6746 key: 'value', 6747 newValue: newVal 6748 }); 6749 } 6750 else {} 6751 } 6752} 6753function isRef(r) { 6754 return !!(r && r.__v_isRef === true); 6755} 6756function ref(value) { 6757 return createRef(value, false); 6758} 6759function shallowRef(value) { 6760 return createRef(value, true); 6761} 6762function createRef(rawValue, shallow) { 6763 if (isRef(rawValue)) { 6764 return rawValue; 6765 } 6766 return new RefImpl(rawValue, shallow); 6767} 6768class RefImpl { 6769 constructor(value, __v_isShallow) { 6770 this.__v_isShallow = __v_isShallow; 6771 this.dep = undefined; 6772 this.__v_isRef = true; 6773 this._rawValue = __v_isShallow ? value : toRaw(value); 6774 this._value = __v_isShallow ? value : toReactive(value); 6775 } 6776 get value() { 6777 trackRefValue(this); 6778 return this._value; 6779 } 6780 set value(newVal) { 6781 const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal); 6782 newVal = useDirectValue ? newVal : toRaw(newVal); 6783 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(newVal, this._rawValue)) { 6784 this._rawValue = newVal; 6785 this._value = useDirectValue ? newVal : toReactive(newVal); 6786 triggerRefValue(this, newVal); 6787 } 6788 } 6789} 6790function triggerRef(ref) { 6791 triggerRefValue(ref, ( true) ? ref.value : 0); 6792} 6793function unref(ref) { 6794 return isRef(ref) ? ref.value : ref; 6795} 6796const shallowUnwrapHandlers = { 6797 get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)), 6798 set: (target, key, value, receiver) => { 6799 const oldValue = target[key]; 6800 if (isRef(oldValue) && !isRef(value)) { 6801 oldValue.value = value; 6802 return true; 6803 } 6804 else { 6805 return Reflect.set(target, key, value, receiver); 6806 } 6807 } 6808}; 6809function proxyRefs(objectWithRefs) { 6810 return isReactive(objectWithRefs) 6811 ? objectWithRefs 6812 : new Proxy(objectWithRefs, shallowUnwrapHandlers); 6813} 6814class CustomRefImpl { 6815 constructor(factory) { 6816 this.dep = undefined; 6817 this.__v_isRef = true; 6818 const { get, set } = factory(() => trackRefValue(this), () => triggerRefValue(this)); 6819 this._get = get; 6820 this._set = set; 6821 } 6822 get value() { 6823 return this._get(); 6824 } 6825 set value(newVal) { 6826 this._set(newVal); 6827 } 6828} 6829function customRef(factory) { 6830 return new CustomRefImpl(factory); 6831} 6832function toRefs(object) { 6833 if (( true) && !isProxy(object)) { 6834 console.warn(`toRefs() expects a reactive object but received a plain one.`); 6835 } 6836 const ret = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(object) ? new Array(object.length) : {}; 6837 for (const key in object) { 6838 ret[key] = toRef(object, key); 6839 } 6840 return ret; 6841} 6842class ObjectRefImpl { 6843 constructor(_object, _key, _defaultValue) { 6844 this._object = _object; 6845 this._key = _key; 6846 this._defaultValue = _defaultValue; 6847 this.__v_isRef = true; 6848 } 6849 get value() { 6850 const val = this._object[this._key]; 6851 return val === undefined ? this._defaultValue : val; 6852 } 6853 set value(newVal) { 6854 this._object[this._key] = newVal; 6855 } 6856} 6857function toRef(object, key, defaultValue) { 6858 const val = object[key]; 6859 return isRef(val) 6860 ? val 6861 : new ObjectRefImpl(object, key, defaultValue); 6862} 6863 6864var _a; 6865class ComputedRefImpl { 6866 constructor(getter, _setter, isReadonly, isSSR) { 6867 this._setter = _setter; 6868 this.dep = undefined; 6869 this.__v_isRef = true; 6870 this[_a] = false; 6871 this._dirty = true; 6872 this.effect = new ReactiveEffect(getter, () => { 6873 if (!this._dirty) { 6874 this._dirty = true; 6875 triggerRefValue(this); 6876 } 6877 }); 6878 this.effect.computed = this; 6879 this.effect.active = this._cacheable = !isSSR; 6880 this["__v_isReadonly" /* ReactiveFlags.IS_READONLY */] = isReadonly; 6881 } 6882 get value() { 6883 // the computed ref may get wrapped by other proxies e.g. readonly() #3376 6884 const self = toRaw(this); 6885 trackRefValue(self); 6886 if (self._dirty || !self._cacheable) { 6887 self._dirty = false; 6888 self._value = self.effect.run(); 6889 } 6890 return self._value; 6891 } 6892 set value(newValue) { 6893 this._setter(newValue); 6894 } 6895} 6896_a = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */; 6897function computed(getterOrOptions, debugOptions, isSSR = false) { 6898 let getter; 6899 let setter; 6900 const onlyGetter = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isFunction)(getterOrOptions); 6901 if (onlyGetter) { 6902 getter = getterOrOptions; 6903 setter = ( true) 6904 ? () => { 6905 console.warn('Write operation failed: computed value is readonly'); 6906 } 6907 : 0; 6908 } 6909 else { 6910 getter = getterOrOptions.get; 6911 setter = getterOrOptions.set; 6912 } 6913 const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR); 6914 if (( true) && debugOptions && !isSSR) { 6915 cRef.effect.onTrack = debugOptions.onTrack; 6916 cRef.effect.onTrigger = debugOptions.onTrigger; 6917 } 6918 return cRef; 6919} 6920 6921var _a$1; 6922const tick = /*#__PURE__*/ Promise.resolve(); 6923const queue = []; 6924let queued = false; 6925const scheduler = (fn) => { 6926 queue.push(fn); 6927 if (!queued) { 6928 queued = true; 6929 tick.then(flush); 6930 } 6931}; 6932const flush = () => { 6933 for (let i = 0; i < queue.length; i++) { 6934 queue[i](); 6935 } 6936 queue.length = 0; 6937 queued = false; 6938}; 6939class DeferredComputedRefImpl { 6940 constructor(getter) { 6941 this.dep = undefined; 6942 this._dirty = true; 6943 this.__v_isRef = true; 6944 this[_a$1] = true; 6945 let compareTarget; 6946 let hasCompareTarget = false; 6947 let scheduled = false; 6948 this.effect = new ReactiveEffect(getter, (computedTrigger) => { 6949 if (this.dep) { 6950 if (computedTrigger) { 6951 compareTarget = this._value; 6952 hasCompareTarget = true; 6953 } 6954 else if (!scheduled) { 6955 const valueToCompare = hasCompareTarget ? compareTarget : this._value; 6956 scheduled = true; 6957 hasCompareTarget = false; 6958 scheduler(() => { 6959 if (this.effect.active && this._get() !== valueToCompare) { 6960 triggerRefValue(this); 6961 } 6962 scheduled = false; 6963 }); 6964 } 6965 // chained upstream computeds are notified synchronously to ensure 6966 // value invalidation in case of sync access; normal effects are 6967 // deferred to be triggered in scheduler. 6968 for (const e of this.dep) { 6969 if (e.computed instanceof DeferredComputedRefImpl) { 6970 e.scheduler(true /* computedTrigger */); 6971 } 6972 } 6973 } 6974 this._dirty = true; 6975 }); 6976 this.effect.computed = this; 6977 } 6978 _get() { 6979 if (this._dirty) { 6980 this._dirty = false; 6981 return (this._value = this.effect.run()); 6982 } 6983 return this._value; 6984 } 6985 get value() { 6986 trackRefValue(this); 6987 // the computed ref may get wrapped by other proxies e.g. readonly() #3376 6988 return toRaw(this)._get(); 6989 } 6990} 6991_a$1 = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */; 6992function deferredComputed(getter) { 6993 return new DeferredComputedRefImpl(getter); 6994} 6995 6996 6997 6998 6999/***/ }), 7000
vendor: 334,024 bytes, lines 7001-15051
7001/***/ "./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js": 7002/*!*************************************************************************!*\ 7003 !*** ./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js ***! 7004 \*************************************************************************/ 7005/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 7006 7007"use strict"; 7008__webpack_require__.r(__webpack_exports__); 7009/* harmony export */ __webpack_require__.d(__webpack_exports__, { 7010/* harmony export */ "BaseTransition": function() { return /* binding */ BaseTransition; }, 7011/* harmony export */ "Comment": function() { return /* binding */ Comment; }, 7012/* harmony export */ "EffectScope": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.EffectScope; }, 7013/* harmony export */ "Fragment": function() { return /* binding */ Fragment; }, 7014/* harmony export */ "KeepAlive": function() { return /* binding */ KeepAlive; }, 7015/* harmony export */ "ReactiveEffect": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect; }, 7016/* harmony export */ "Static": function() { return /* binding */ Static; }, 7017/* harmony export */ "Suspense": function() { return /* binding */ Suspense; }, 7018/* harmony export */ "Teleport": function() { return /* binding */ Teleport; }, 7019/* harmony export */ "Text": function() { return /* binding */ Text; }, 7020/* harmony export */ "callWithAsyncErrorHandling": function() { return /* binding */ callWithAsyncErrorHandling; }, 7021/* harmony export */ "callWithErrorHandling": function() { return /* binding */ callWithErrorHandling; }, 7022/* harmony export */ "camelize": function() { return /* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize; }, 7023/* harmony export */ "capitalize": function() { return /* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize; }, 7024/* harmony export */ "cloneVNode": function() { return /* binding */ cloneVNode; }, 7025/* harmony export */ "compatUtils": function() { return /* binding */ compatUtils; }, 7026/* harmony export */ "computed": function() { return /* binding */ computed; }, 7027/* harmony export */ "createBlock": function() { return /* binding */ createBlock; }, 7028/* harmony export */ "createCommentVNode": function() { return /* binding */ createCommentVNode; }, 7029/* harmony export */ "createElementBlock": function() { return /* binding */ createElementBlock; }, 7030/* harmony export */ "createElementVNode": function() { return /* binding */ createBaseVNode; }, 7031/* harmony export */ "createHydrationRenderer": function() { return /* binding */ createHydrationRenderer; }, 7032/* harmony export */ "createPropsRestProxy": function() { return /* binding */ createPropsRestProxy; }, 7033/* harmony export */ "createRenderer": function() { return /* binding */ createRenderer; }, 7034/* harmony export */ "createSlots": function() { return /* binding */ createSlots; }, 7035/* harmony export */ "createStaticVNode": function() { return /* binding */ createStaticVNode; }, 7036/* harmony export */ "createTextVNode": function() { return /* binding */ createTextVNode; }, 7037/* harmony export */ "createVNode": function() { return /* binding */ createVNode; }, 7038/* harmony export */ "customRef": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.customRef; }, 7039/* harmony export */ "defineAsyncComponent": function() { return /* binding */ defineAsyncComponent; }, 7040/* harmony export */ "defineComponent": function() { return /* binding */ defineComponent; }, 7041/* harmony export */ "defineEmits": function() { return /* binding */ defineEmits; }, 7042/* harmony export */ "defineExpose": function() { return /* binding */ defineExpose; }, 7043/* harmony export */ "defineProps": function() { return /* binding */ defineProps; }, 7044/* harmony export */ "devtools": function() { return /* binding */ devtools; }, 7045/* harmony export */ "effect": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.effect; }, 7046/* harmony export */ "effectScope": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.effectScope; }, 7047/* harmony export */ "getCurrentInstance": function() { return /* binding */ getCurrentInstance; }, 7048/* harmony export */ "getCurrentScope": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope; }, 7049/* harmony export */ "getTransitionRawChildren": function() { return /* binding */ getTransitionRawChildren; }, 7050/* harmony export */ "guardReactiveProps": function() { return /* binding */ guardReactiveProps; }, 7051/* harmony export */ "h": function() { return /* binding */ h; }, 7052/* harmony export */ "handleError": function() { return /* binding */ handleError; }, 7053/* harmony export */ "initCustomFormatter": function() { return /* binding */ initCustomFormatter; }, 7054/* harmony export */ "inject": function() { return /* binding */ inject; }, 7055/* harmony export */ "isMemoSame": function() { return /* binding */ isMemoSame; }, 7056/* harmony export */ "isProxy": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy; }, 7057/* harmony export */ "isReactive": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive; }, 7058/* harmony export */ "isReadonly": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReadonly; }, 7059/* harmony export */ "isRef": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef; }, 7060/* harmony export */ "isRuntimeOnly": function() { return /* binding */ isRuntimeOnly; }, 7061/* harmony export */ "isShallow": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow; }, 7062/* harmony export */ "isVNode": function() { return /* binding */ isVNode; }, 7063/* harmony export */ "markRaw": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.markRaw; }, 7064/* harmony export */ "mergeDefaults": function() { return /* binding */ mergeDefaults; }, 7065/* harmony export */ "mergeProps": function() { return /* binding */ mergeProps; }, 7066/* harmony export */ "nextTick": function() { return /* binding */ nextTick; }, 7067/* harmony export */ "normalizeClass": function() { return /* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass; }, 7068/* harmony export */ "normalizeProps": function() { return /* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeProps; }, 7069/* harmony export */ "normalizeStyle": function() { return /* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle; }, 7070/* harmony export */ "onActivated": function() { return /* binding */ onActivated; }, 7071/* harmony export */ "onBeforeMount": function() { return /* binding */ onBeforeMount; }, 7072/* harmony export */ "onBeforeUnmount": function() { return /* binding */ onBeforeUnmount; }, 7073/* harmony export */ "onBeforeUpdate": function() { return /* binding */ onBeforeUpdate; }, 7074/* harmony export */ "onDeactivated": function() { return /* binding */ onDeactivated; }, 7075/* harmony export */ "onErrorCaptured": function() { return /* binding */ onErrorCaptured; }, 7076/* harmony export */ "onMounted": function() { return /* binding */ onMounted; }, 7077/* harmony export */ "onRenderTracked": function() { return /* binding */ onRenderTracked; }, 7078/* harmony export */ "onRenderTriggered": function() { return /* binding */ onRenderTriggered; }, 7079/* harmony export */ "onScopeDispose": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose; }, 7080/* harmony export */ "onServerPrefetch": function() { return /* binding */ onServerPrefetch; }, 7081/* harmony export */ "onUnmounted": function() { return /* binding */ onUnmounted; }, 7082/* harmony export */ "onUpdated": function() { return /* binding */ onUpdated; }, 7083/* harmony export */ "openBlock": function() { return /* binding */ openBlock; }, 7084/* harmony export */ "popScopeId": function() { return /* binding */ popScopeId; }, 7085/* harmony export */ "provide": function() { return /* binding */ provide; }, 7086/* harmony export */ "proxyRefs": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.proxyRefs; }, 7087/* harmony export */ "pushScopeId": function() { return /* binding */ pushScopeId; }, 7088/* harmony export */ "queuePostFlushCb": function() { return /* binding */ queuePostFlushCb; }, 7089/* harmony export */ "reactive": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.reactive; }, 7090/* harmony export */ "readonly": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.readonly; }, 7091/* harmony export */ "ref": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref; }, 7092/* harmony export */ "registerRuntimeCompiler": function() { return /* binding */ registerRuntimeCompiler; }, 7093/* harmony export */ "renderList": function() { return /* binding */ renderList; }, 7094/* harmony export */ "renderSlot": function() { return /* binding */ renderSlot; }, 7095/* harmony export */ "resolveComponent": function() { return /* binding */ resolveComponent; }, 7096/* harmony export */ "resolveDirective": function() { return /* binding */ resolveDirective; }, 7097/* harmony export */ "resolveDynamicComponent": function() { return /* binding */ resolveDynamicComponent; }, 7098/* harmony export */ "resolveFilter": function() { return /* binding */ resolveFilter; }, 7099/* harmony export */ "resolveTransitionHooks": function() { return /* binding */ resolveTransitionHooks; }, 7100/* harmony export */ "setBlockTracking": function() { return /* binding */ setBlockTracking; }, 7101/* harmony export */ "setDevtoolsHook": function() { return /* binding */ setDevtoolsHook; }, 7102/* harmony export */ "setTransitionHooks": function() { return /* binding */ setTransitionHooks; }, 7103/* harmony export */ "shallowReactive": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReactive; }, 7104/* harmony export */ "shallowReadonly": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly; }, 7105/* harmony export */ "shallowRef": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowRef; }, 7106/* harmony export */ "ssrContextKey": function() { return /* binding */ ssrContextKey; }, 7107/* harmony export */ "ssrUtils": function() { return /* binding */ ssrUtils; }, 7108/* harmony export */ "stop": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.stop; }, 7109/* harmony export */ "toDisplayString": function() { return /* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.toDisplayString; }, 7110/* harmony export */ "toHandlerKey": function() { return /* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey; }, 7111/* harmony export */ "toHandlers": function() { return /* binding */ toHandlers; }, 7112/* harmony export */ "toRaw": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw; }, 7113/* harmony export */ "toRef": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRef; }, 7114/* harmony export */ "toRefs": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRefs; }, 7115/* harmony export */ "transformVNodeArgs": function() { return /* binding */ transformVNodeArgs; }, 7116/* harmony export */ "triggerRef": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.triggerRef; }, 7117/* harmony export */ "unref": function() { return /* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.unref; }, 7118/* harmony export */ "useAttrs": function() { return /* binding */ useAttrs; }, 7119/* harmony export */ "useSSRContext": function() { return /* binding */ useSSRContext; }, 7120/* harmony export */ "useSlots": function() { return /* binding */ useSlots; }, 7121/* harmony export */ "useTransitionState": function() { return /* binding */ useTransitionState; }, 7122/* harmony export */ "version": function() { return /* binding */ version; }, 7123/* harmony export */ "warn": function() { return /* binding */ warn; }, 7124/* harmony export */ "watch": function() { return /* binding */ watch; }, 7125/* harmony export */ "watchEffect": function() { return /* binding */ watchEffect; }, 7126/* harmony export */ "watchPostEffect": function() { return /* binding */ watchPostEffect; }, 7127/* harmony export */ "watchSyncEffect": function() { return /* binding */ watchSyncEffect; }, 7128/* harmony export */ "withAsyncContext": function() { return /* binding */ withAsyncContext; }, 7129/* harmony export */ "withCtx": function() { return /* binding */ withCtx; }, 7130/* harmony export */ "withDefaults": function() { return /* binding */ withDefaults; }, 7131/* harmony export */ "withDirectives": function() { return /* binding */ withDirectives; }, 7132/* harmony export */ "withMemo": function() { return /* binding */ withMemo; }, 7133/* harmony export */ "withScopeId": function() { return /* binding */ withScopeId; } 7134/* harmony export */ }); 7135/* harmony import */ var _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/reactivity */ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js"); 7136/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 7137 7138 7139 7140 7141 7142const stack = []; 7143function pushWarningContext(vnode) { 7144 stack.push(vnode); 7145} 7146function popWarningContext() { 7147 stack.pop(); 7148} 7149function warn(msg, ...args) { 7150 if (false) 7151 {} 7152 // avoid props formatting or warn handler tracking deps that might be mutated 7153 // during patch, leading to infinite recursion. 7154 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 7155 const instance = stack.length ? stack[stack.length - 1].component : null; 7156 const appWarnHandler = instance && instance.appContext.config.warnHandler; 7157 const trace = getComponentTrace(); 7158 if (appWarnHandler) { 7159 callWithErrorHandling(appWarnHandler, instance, 11 /* ErrorCodes.APP_WARN_HANDLER */, [ 7160 msg + args.join(''), 7161 instance && instance.proxy, 7162 trace 7163 .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`) 7164 .join('\n'), 7165 trace 7166 ]); 7167 } 7168 else { 7169 const warnArgs = [`[Vue warn]: ${msg}`, ...args]; 7170 /* istanbul ignore if */ 7171 if (trace.length && 7172 // avoid spamming console during tests 7173 !false) { 7174 warnArgs.push(`\n`, ...formatTrace(trace)); 7175 } 7176 console.warn(...warnArgs); 7177 } 7178 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 7179} 7180function getComponentTrace() { 7181 let currentVNode = stack[stack.length - 1]; 7182 if (!currentVNode) { 7183 return []; 7184 } 7185 // we can't just use the stack because it will be incomplete during updates 7186 // that did not start from the root. Re-construct the parent chain using 7187 // instance parent pointers. 7188 const normalizedStack = []; 7189 while (currentVNode) { 7190 const last = normalizedStack[0]; 7191 if (last && last.vnode === currentVNode) { 7192 last.recurseCount++; 7193 } 7194 else { 7195 normalizedStack.push({ 7196 vnode: currentVNode, 7197 recurseCount: 0 7198 }); 7199 } 7200 const parentInstance = currentVNode.component && currentVNode.component.parent; 7201 currentVNode = parentInstance && parentInstance.vnode; 7202 } 7203 return normalizedStack; 7204} 7205/* istanbul ignore next */ 7206function formatTrace(trace) { 7207 const logs = []; 7208 trace.forEach((entry, i) => { 7209 logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry(entry)); 7210 }); 7211 return logs; 7212} 7213function formatTraceEntry({ vnode, recurseCount }) { 7214 const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; 7215 const isRoot = vnode.component ? vnode.component.parent == null : false; 7216 const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`; 7217 const close = `>` + postfix; 7218 return vnode.props 7219 ? [open, ...formatProps(vnode.props), close] 7220 : [open + close]; 7221} 7222/* istanbul ignore next */ 7223function formatProps(props) { 7224 const res = []; 7225 const keys = Object.keys(props); 7226 keys.slice(0, 3).forEach(key => { 7227 res.push(...formatProp(key, props[key])); 7228 }); 7229 if (keys.length > 3) { 7230 res.push(` ...`); 7231 } 7232 return res; 7233} 7234/* istanbul ignore next */ 7235function formatProp(key, value, raw) { 7236 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(value)) { 7237 value = JSON.stringify(value); 7238 return raw ? value : [`${key}=${value}`]; 7239 } 7240 else if (typeof value === 'number' || 7241 typeof value === 'boolean' || 7242 value == null) { 7243 return raw ? value : [`${key}=${value}`]; 7244 } 7245 else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(value)) { 7246 value = formatProp(key, (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(value.value), true); 7247 return raw ? value : [`${key}=Ref<`, value, `>`]; 7248 } 7249 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) { 7250 return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; 7251 } 7252 else { 7253 value = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(value); 7254 return raw ? value : [`${key}=`, value]; 7255 } 7256} 7257 7258const ErrorTypeStrings = { 7259 ["sp" /* LifecycleHooks.SERVER_PREFETCH */]: 'serverPrefetch hook', 7260 ["bc" /* LifecycleHooks.BEFORE_CREATE */]: 'beforeCreate hook', 7261 ["c" /* LifecycleHooks.CREATED */]: 'created hook', 7262 ["bm" /* LifecycleHooks.BEFORE_MOUNT */]: 'beforeMount hook', 7263 ["m" /* LifecycleHooks.MOUNTED */]: 'mounted hook', 7264 ["bu" /* LifecycleHooks.BEFORE_UPDATE */]: 'beforeUpdate hook', 7265 ["u" /* LifecycleHooks.UPDATED */]: 'updated', 7266 ["bum" /* LifecycleHooks.BEFORE_UNMOUNT */]: 'beforeUnmount hook', 7267 ["um" /* LifecycleHooks.UNMOUNTED */]: 'unmounted hook', 7268 ["a" /* LifecycleHooks.ACTIVATED */]: 'activated hook', 7269 ["da" /* LifecycleHooks.DEACTIVATED */]: 'deactivated hook', 7270 ["ec" /* LifecycleHooks.ERROR_CAPTURED */]: 'errorCaptured hook', 7271 ["rtc" /* LifecycleHooks.RENDER_TRACKED */]: 'renderTracked hook', 7272 ["rtg" /* LifecycleHooks.RENDER_TRIGGERED */]: 'renderTriggered hook', 7273 [0 /* ErrorCodes.SETUP_FUNCTION */]: 'setup function', 7274 [1 /* ErrorCodes.RENDER_FUNCTION */]: 'render function', 7275 [2 /* ErrorCodes.WATCH_GETTER */]: 'watcher getter', 7276 [3 /* ErrorCodes.WATCH_CALLBACK */]: 'watcher callback', 7277 [4 /* ErrorCodes.WATCH_CLEANUP */]: 'watcher cleanup function', 7278 [5 /* ErrorCodes.NATIVE_EVENT_HANDLER */]: 'native event handler', 7279 [6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */]: 'component event handler', 7280 [7 /* ErrorCodes.VNODE_HOOK */]: 'vnode hook', 7281 [8 /* ErrorCodes.DIRECTIVE_HOOK */]: 'directive hook', 7282 [9 /* ErrorCodes.TRANSITION_HOOK */]: 'transition hook', 7283 [10 /* ErrorCodes.APP_ERROR_HANDLER */]: 'app errorHandler', 7284 [11 /* ErrorCodes.APP_WARN_HANDLER */]: 'app warnHandler', 7285 [12 /* ErrorCodes.FUNCTION_REF */]: 'ref function', 7286 [13 /* ErrorCodes.ASYNC_COMPONENT_LOADER */]: 'async component loader', 7287 [14 /* ErrorCodes.SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' + 7288 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core' 7289}; 7290function callWithErrorHandling(fn, instance, type, args) { 7291 let res; 7292 try { 7293 res = args ? fn(...args) : fn(); 7294 } 7295 catch (err) { 7296 handleError(err, instance, type); 7297 } 7298 return res; 7299} 7300function callWithAsyncErrorHandling(fn, instance, type, args) { 7301 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(fn)) { 7302 const res = callWithErrorHandling(fn, instance, type, args); 7303 if (res && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(res)) { 7304 res.catch(err => { 7305 handleError(err, instance, type); 7306 }); 7307 } 7308 return res; 7309 } 7310 const values = []; 7311 for (let i = 0; i < fn.length; i++) { 7312 values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); 7313 } 7314 return values; 7315} 7316function handleError(err, instance, type, throwInDev = true) { 7317 const contextVNode = instance ? instance.vnode : null; 7318 if (instance) { 7319 let cur = instance.parent; 7320 // the exposed instance is the render proxy to keep it consistent with 2.x 7321 const exposedInstance = instance.proxy; 7322 // in production the hook receives only the error code 7323 const errorInfo = ( true) ? ErrorTypeStrings[type] : 0; 7324 while (cur) { 7325 const errorCapturedHooks = cur.ec; 7326 if (errorCapturedHooks) { 7327 for (let i = 0; i < errorCapturedHooks.length; i++) { 7328 if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { 7329 return; 7330 } 7331 } 7332 } 7333 cur = cur.parent; 7334 } 7335 // app-level handling 7336 const appErrorHandler = instance.appContext.config.errorHandler; 7337 if (appErrorHandler) { 7338 callWithErrorHandling(appErrorHandler, null, 10 /* ErrorCodes.APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]); 7339 return; 7340 } 7341 } 7342 logError(err, type, contextVNode, throwInDev); 7343} 7344function logError(err, type, contextVNode, throwInDev = true) { 7345 if ((true)) { 7346 const info = ErrorTypeStrings[type]; 7347 if (contextVNode) { 7348 pushWarningContext(contextVNode); 7349 } 7350 warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`); 7351 if (contextVNode) { 7352 popWarningContext(); 7353 } 7354 // crash in dev by default so it's more noticeable 7355 if (throwInDev) { 7356 throw err; 7357 } 7358 else { 7359 console.error(err); 7360 } 7361 } 7362 else {} 7363} 7364 7365let isFlushing = false; 7366let isFlushPending = false; 7367const queue = []; 7368let flushIndex = 0; 7369const pendingPostFlushCbs = []; 7370let activePostFlushCbs = null; 7371let postFlushIndex = 0; 7372const resolvedPromise = /*#__PURE__*/ Promise.resolve(); 7373let currentFlushPromise = null; 7374const RECURSION_LIMIT = 100; 7375function nextTick(fn) { 7376 const p = currentFlushPromise || resolvedPromise; 7377 return fn ? p.then(this ? fn.bind(this) : fn) : p; 7378} 7379// #2768 7380// Use binary-search to find a suitable position in the queue, 7381// so that the queue maintains the increasing order of job's id, 7382// which can prevent the job from being skipped and also can avoid repeated patching. 7383function findInsertionIndex(id) { 7384 // the start index should be `flushIndex + 1` 7385 let start = flushIndex + 1; 7386 let end = queue.length; 7387 while (start < end) { 7388 const middle = (start + end) >>> 1; 7389 const middleJobId = getId(queue[middle]); 7390 middleJobId < id ? (start = middle + 1) : (end = middle); 7391 } 7392 return start; 7393} 7394function queueJob(job) { 7395 // the dedupe search uses the startIndex argument of Array.includes() 7396 // by default the search index includes the current job that is being run 7397 // so it cannot recursively trigger itself again. 7398 // if the job is a watch() callback, the search will start with a +1 index to 7399 // allow it recursively trigger itself - it is the user's responsibility to 7400 // ensure it doesn't end up in an infinite loop. 7401 if (!queue.length || 7402 !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) { 7403 if (job.id == null) { 7404 queue.push(job); 7405 } 7406 else { 7407 queue.splice(findInsertionIndex(job.id), 0, job); 7408 } 7409 queueFlush(); 7410 } 7411} 7412function queueFlush() { 7413 if (!isFlushing && !isFlushPending) { 7414 isFlushPending = true; 7415 currentFlushPromise = resolvedPromise.then(flushJobs); 7416 } 7417} 7418function invalidateJob(job) { 7419 const i = queue.indexOf(job); 7420 if (i > flushIndex) { 7421 queue.splice(i, 1); 7422 } 7423} 7424function queuePostFlushCb(cb) { 7425 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(cb)) { 7426 if (!activePostFlushCbs || 7427 !activePostFlushCbs.includes(cb, cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex)) { 7428 pendingPostFlushCbs.push(cb); 7429 } 7430 } 7431 else { 7432 // if cb is an array, it is a component lifecycle hook which can only be 7433 // triggered by a job, which is already deduped in the main queue, so 7434 // we can skip duplicate check here to improve perf 7435 pendingPostFlushCbs.push(...cb); 7436 } 7437 queueFlush(); 7438} 7439function flushPreFlushCbs(seen, 7440// if currently flushing, skip the current job itself 7441i = isFlushing ? flushIndex + 1 : 0) { 7442 if ((true)) { 7443 seen = seen || new Map(); 7444 } 7445 for (; i < queue.length; i++) { 7446 const cb = queue[i]; 7447 if (cb && cb.pre) { 7448 if (( true) && checkRecursiveUpdates(seen, cb)) { 7449 continue; 7450 } 7451 queue.splice(i, 1); 7452 i--; 7453 cb(); 7454 } 7455 } 7456} 7457function flushPostFlushCbs(seen) { 7458 if (pendingPostFlushCbs.length) { 7459 const deduped = [...new Set(pendingPostFlushCbs)]; 7460 pendingPostFlushCbs.length = 0; 7461 // #1947 already has active queue, nested flushPostFlushCbs call 7462 if (activePostFlushCbs) { 7463 activePostFlushCbs.push(...deduped); 7464 return; 7465 } 7466 activePostFlushCbs = deduped; 7467 if ((true)) { 7468 seen = seen || new Map(); 7469 } 7470 activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); 7471 for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { 7472 if (( true) && 7473 checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) { 7474 continue; 7475 } 7476 activePostFlushCbs[postFlushIndex](); 7477 } 7478 activePostFlushCbs = null; 7479 postFlushIndex = 0; 7480 } 7481} 7482const getId = (job) => job.id == null ? Infinity : job.id; 7483const comparator = (a, b) => { 7484 const diff = getId(a) - getId(b); 7485 if (diff === 0) { 7486 if (a.pre && !b.pre) 7487 return -1; 7488 if (b.pre && !a.pre) 7489 return 1; 7490 } 7491 return diff; 7492}; 7493function flushJobs(seen) { 7494 isFlushPending = false; 7495 isFlushing = true; 7496 if ((true)) { 7497 seen = seen || new Map(); 7498 } 7499 // Sort queue before flush. 7500 // This ensures that: 7501 // 1. Components are updated from parent to child. (because parent is always 7502 // created before the child so its render effect will have smaller 7503 // priority number) 7504 // 2. If a component is unmounted during a parent component's update, 7505 // its update can be skipped. 7506 queue.sort(comparator); 7507 // conditional usage of checkRecursiveUpdate must be determined out of 7508 // try ... catch block since Rollup by default de-optimizes treeshaking 7509 // inside try-catch. This can leave all warning code unshaked. Although 7510 // they would get eventually shaken by a minifier like terser, some minifiers 7511 // would fail to do that (e.g. https://github.com/evanw/esbuild/issues/1610) 7512 const check = ( true) 7513 ? (job) => checkRecursiveUpdates(seen, job) 7514 : 0; 7515 try { 7516 for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { 7517 const job = queue[flushIndex]; 7518 if (job && job.active !== false) { 7519 if (( true) && check(job)) { 7520 continue; 7521 } 7522 // console.log(`running:`, job.id) 7523 callWithErrorHandling(job, null, 14 /* ErrorCodes.SCHEDULER */); 7524 } 7525 } 7526 } 7527 finally { 7528 flushIndex = 0; 7529 queue.length = 0; 7530 flushPostFlushCbs(seen); 7531 isFlushing = false; 7532 currentFlushPromise = null; 7533 // some postFlushCb queued jobs! 7534 // keep flushing until it drains. 7535 if (queue.length || pendingPostFlushCbs.length) { 7536 flushJobs(seen); 7537 } 7538 } 7539} 7540function checkRecursiveUpdates(seen, fn) { 7541 if (!seen.has(fn)) { 7542 seen.set(fn, 1); 7543 } 7544 else { 7545 const count = seen.get(fn); 7546 if (count > RECURSION_LIMIT) { 7547 const instance = fn.ownerInstance; 7548 const componentName = instance && getComponentName(instance.type); 7549 warn(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. ` + 7550 `This means you have a reactive effect that is mutating its own ` + 7551 `dependencies and thus recursively triggering itself. Possible sources ` + 7552 `include component template, render function, updated hook or ` + 7553 `watcher source function.`); 7554 return true; 7555 } 7556 else { 7557 seen.set(fn, count + 1); 7558 } 7559 } 7560} 7561 7562/* eslint-disable no-restricted-globals */ 7563let isHmrUpdating = false; 7564const hmrDirtyComponents = new Set(); 7565// Expose the HMR runtime on the global object 7566// This makes it entirely tree-shakable without polluting the exports and makes 7567// it easier to be used in toolings like vue-loader 7568// Note: for a component to be eligible for HMR it also needs the __hmrId option 7569// to be set so that its instances can be registered / removed. 7570if ((true)) { 7571 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)().__VUE_HMR_RUNTIME__ = { 7572 createRecord: tryWrap(createRecord), 7573 rerender: tryWrap(rerender), 7574 reload: tryWrap(reload) 7575 }; 7576} 7577const map = new Map(); 7578function registerHMR(instance) { 7579 const id = instance.type.__hmrId; 7580 let record = map.get(id); 7581 if (!record) { 7582 createRecord(id, instance.type); 7583 record = map.get(id); 7584 } 7585 record.instances.add(instance); 7586} 7587function unregisterHMR(instance) { 7588 map.get(instance.type.__hmrId).instances.delete(instance); 7589} 7590function createRecord(id, initialDef) { 7591 if (map.has(id)) { 7592 return false; 7593 } 7594 map.set(id, { 7595 initialDef: normalizeClassComponent(initialDef), 7596 instances: new Set() 7597 }); 7598 return true; 7599} 7600function normalizeClassComponent(component) { 7601 return isClassComponent(component) ? component.__vccOpts : component; 7602} 7603function rerender(id, newRender) { 7604 const record = map.get(id); 7605 if (!record) { 7606 return; 7607 } 7608 // update initial record (for not-yet-rendered component) 7609 record.initialDef.render = newRender; 7610 [...record.instances].forEach(instance => { 7611 if (newRender) { 7612 instance.render = newRender; 7613 normalizeClassComponent(instance.type).render = newRender; 7614 } 7615 instance.renderCache = []; 7616 // this flag forces child components with slot content to update 7617 isHmrUpdating = true; 7618 instance.update(); 7619 isHmrUpdating = false; 7620 }); 7621} 7622function reload(id, newComp) { 7623 const record = map.get(id); 7624 if (!record) 7625 return; 7626 newComp = normalizeClassComponent(newComp); 7627 // update initial def (for not-yet-rendered components) 7628 updateComponentDef(record.initialDef, newComp); 7629 // create a snapshot which avoids the set being mutated during updates 7630 const instances = [...record.instances]; 7631 for (const instance of instances) { 7632 const oldComp = normalizeClassComponent(instance.type); 7633 if (!hmrDirtyComponents.has(oldComp)) { 7634 // 1. Update existing comp definition to match new one 7635 if (oldComp !== record.initialDef) { 7636 updateComponentDef(oldComp, newComp); 7637 } 7638 // 2. mark definition dirty. This forces the renderer to replace the 7639 // component on patch. 7640 hmrDirtyComponents.add(oldComp); 7641 } 7642 // 3. invalidate options resolution cache 7643 instance.appContext.optionsCache.delete(instance.type); 7644 // 4. actually update 7645 if (instance.ceReload) { 7646 // custom element 7647 hmrDirtyComponents.add(oldComp); 7648 instance.ceReload(newComp.styles); 7649 hmrDirtyComponents.delete(oldComp); 7650 } 7651 else if (instance.parent) { 7652 // 4. Force the parent instance to re-render. This will cause all updated 7653 // components to be unmounted and re-mounted. Queue the update so that we 7654 // don't end up forcing the same parent to re-render multiple times. 7655 queueJob(instance.parent.update); 7656 } 7657 else if (instance.appContext.reload) { 7658 // root instance mounted via createApp() has a reload method 7659 instance.appContext.reload(); 7660 } 7661 else if (typeof window !== 'undefined') { 7662 // root instance inside tree created via raw render(). Force reload. 7663 window.location.reload(); 7664 } 7665 else { 7666 console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); 7667 } 7668 } 7669 // 5. make sure to cleanup dirty hmr components after update 7670 queuePostFlushCb(() => { 7671 for (const instance of instances) { 7672 hmrDirtyComponents.delete(normalizeClassComponent(instance.type)); 7673 } 7674 }); 7675} 7676function updateComponentDef(oldComp, newComp) { 7677 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(oldComp, newComp); 7678 for (const key in oldComp) { 7679 if (key !== '__file' && !(key in newComp)) { 7680 delete oldComp[key]; 7681 } 7682 } 7683} 7684function tryWrap(fn) { 7685 return (id, arg) => { 7686 try { 7687 return fn(id, arg); 7688 } 7689 catch (e) { 7690 console.error(e); 7691 console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` + 7692 `Full reload required.`); 7693 } 7694 }; 7695} 7696 7697let devtools; 7698let buffer = []; 7699let devtoolsNotInstalled = false; 7700function emit(event, ...args) { 7701 if (devtools) { 7702 devtools.emit(event, ...args); 7703 } 7704 else if (!devtoolsNotInstalled) { 7705 buffer.push({ event, args }); 7706 } 7707} 7708function setDevtoolsHook(hook, target) { 7709 var _a, _b; 7710 devtools = hook; 7711 if (devtools) { 7712 devtools.enabled = true; 7713 buffer.forEach(({ event, args }) => devtools.emit(event, ...args)); 7714 buffer = []; 7715 } 7716 else if ( 7717 // handle late devtools injection - only do this if we are in an actual 7718 // browser environment to avoid the timer handle stalling test runner exit 7719 // (#4815) 7720 typeof window !== 'undefined' && 7721 // some envs mock window but not fully 7722 window.HTMLElement && 7723 // also exclude jsdom 7724 !((_b = (_a = window.navigator) === null || _a === void 0 ? void 0 : _a.userAgent) === null || _b === void 0 ? void 0 : _b.includes('jsdom'))) { 7725 const replay = (target.__VUE_DEVTOOLS_HOOK_REPLAY__ = 7726 target.__VUE_DEVTOOLS_HOOK_REPLAY__ || []); 7727 replay.push((newHook) => { 7728 setDevtoolsHook(newHook, target); 7729 }); 7730 // clear buffer after 3s - the user probably doesn't have devtools installed 7731 // at all, and keeping the buffer will cause memory leaks (#4738) 7732 setTimeout(() => { 7733 if (!devtools) { 7734 target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null; 7735 devtoolsNotInstalled = true; 7736 buffer = []; 7737 } 7738 }, 3000); 7739 } 7740 else { 7741 // non-browser env, assume not installed 7742 devtoolsNotInstalled = true; 7743 buffer = []; 7744 } 7745} 7746function devtoolsInitApp(app, version) { 7747 emit("app:init" /* DevtoolsHooks.APP_INIT */, app, version, { 7748 Fragment, 7749 Text, 7750 Comment, 7751 Static 7752 }); 7753} 7754function devtoolsUnmountApp(app) { 7755 emit("app:unmount" /* DevtoolsHooks.APP_UNMOUNT */, app); 7756} 7757const devtoolsComponentAdded = /*#__PURE__*/ createDevtoolsComponentHook("component:added" /* DevtoolsHooks.COMPONENT_ADDED */); 7758const devtoolsComponentUpdated = 7759/*#__PURE__*/ createDevtoolsComponentHook("component:updated" /* DevtoolsHooks.COMPONENT_UPDATED */); 7760const _devtoolsComponentRemoved = /*#__PURE__*/ createDevtoolsComponentHook("component:removed" /* DevtoolsHooks.COMPONENT_REMOVED */); 7761const devtoolsComponentRemoved = (component) => { 7762 if (devtools && 7763 typeof devtools.cleanupBuffer === 'function' && 7764 // remove the component if it wasn't buffered 7765 !devtools.cleanupBuffer(component)) { 7766 _devtoolsComponentRemoved(component); 7767 } 7768}; 7769function createDevtoolsComponentHook(hook) { 7770 return (component) => { 7771 emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined, component); 7772 }; 7773} 7774const devtoolsPerfStart = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:start" /* DevtoolsHooks.PERFORMANCE_START */); 7775const devtoolsPerfEnd = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:end" /* DevtoolsHooks.PERFORMANCE_END */); 7776function createDevtoolsPerformanceHook(hook) { 7777 return (component, type, time) => { 7778 emit(hook, component.appContext.app, component.uid, component, type, time); 7779 }; 7780} 7781function devtoolsComponentEmit(component, event, params) { 7782 emit("component:emit" /* DevtoolsHooks.COMPONENT_EMIT */, component.appContext.app, component, event, params); 7783} 7784 7785function emit$1(instance, event, ...rawArgs) { 7786 if (instance.isUnmounted) 7787 return; 7788 const props = instance.vnode.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 7789 if ((true)) { 7790 const { emitsOptions, propsOptions: [propsOptions] } = instance; 7791 if (emitsOptions) { 7792 if (!(event in emitsOptions) && 7793 !(false )) { 7794 if (!propsOptions || !((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(event) in propsOptions)) { 7795 warn(`Component emitted event "${event}" but it is neither declared in ` + 7796 `the emits option nor as an "${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(event)}" prop.`); 7797 } 7798 } 7799 else { 7800 const validator = emitsOptions[event]; 7801 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(validator)) { 7802 const isValid = validator(...rawArgs); 7803 if (!isValid) { 7804 warn(`Invalid event arguments: event validation failed for event "${event}".`); 7805 } 7806 } 7807 } 7808 } 7809 } 7810 let args = rawArgs; 7811 const isModelListener = event.startsWith('update:'); 7812 // for v-model update:xxx events, apply modifiers on args 7813 const modelArg = isModelListener && event.slice(7); 7814 if (modelArg && modelArg in props) { 7815 const modifiersKey = `${modelArg === 'modelValue' ? 'model' : modelArg}Modifiers`; 7816 const { number, trim } = props[modifiersKey] || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 7817 if (trim) { 7818 args = rawArgs.map(a => ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(a) ? a.trim() : a)); 7819 } 7820 if (number) { 7821 args = rawArgs.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber); 7822 } 7823 } 7824 if (true) { 7825 devtoolsComponentEmit(instance, event, args); 7826 } 7827 if ((true)) { 7828 const lowerCaseEvent = event.toLowerCase(); 7829 if (lowerCaseEvent !== event && props[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(lowerCaseEvent)]) { 7830 warn(`Event "${lowerCaseEvent}" is emitted in component ` + 7831 `${formatComponentName(instance, instance.type)} but the handler is registered for "${event}". ` + 7832 `Note that HTML attributes are case-insensitive and you cannot use ` + 7833 `v-on to listen to camelCase events when using in-DOM templates. ` + 7834 `You should probably use "${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event)}" instead of "${event}".`); 7835 } 7836 } 7837 let handlerName; 7838 let handler = props[(handlerName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(event))] || 7839 // also try camelCase event handler (#2249) 7840 props[(handlerName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(event)))]; 7841 // for v-model update:xxx events, also trigger kebab-case equivalent 7842 // for props passed via kebab-case 7843 if (!handler && isModelListener) { 7844 handler = props[(handlerName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event)))]; 7845 } 7846 if (handler) { 7847 callWithAsyncErrorHandling(handler, instance, 6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */, args); 7848 } 7849 const onceHandler = props[handlerName + `Once`]; 7850 if (onceHandler) { 7851 if (!instance.emitted) { 7852 instance.emitted = {}; 7853 } 7854 else if (instance.emitted[handlerName]) { 7855 return; 7856 } 7857 instance.emitted[handlerName] = true; 7858 callWithAsyncErrorHandling(onceHandler, instance, 6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */, args); 7859 } 7860} 7861function normalizeEmitsOptions(comp, appContext, asMixin = false) { 7862 const cache = appContext.emitsCache; 7863 const cached = cache.get(comp); 7864 if (cached !== undefined) { 7865 return cached; 7866 } 7867 const raw = comp.emits; 7868 let normalized = {}; 7869 // apply mixin/extends props 7870 let hasExtends = false; 7871 if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(comp)) { 7872 const extendEmits = (raw) => { 7873 const normalizedFromExtend = normalizeEmitsOptions(raw, appContext, true); 7874 if (normalizedFromExtend) { 7875 hasExtends = true; 7876 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(normalized, normalizedFromExtend); 7877 } 7878 }; 7879 if (!asMixin && appContext.mixins.length) { 7880 appContext.mixins.forEach(extendEmits); 7881 } 7882 if (comp.extends) { 7883 extendEmits(comp.extends); 7884 } 7885 if (comp.mixins) { 7886 comp.mixins.forEach(extendEmits); 7887 } 7888 } 7889 if (!raw && !hasExtends) { 7890 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) { 7891 cache.set(comp, null); 7892 } 7893 return null; 7894 } 7895 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) { 7896 raw.forEach(key => (normalized[key] = null)); 7897 } 7898 else { 7899 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(normalized, raw); 7900 } 7901 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) { 7902 cache.set(comp, normalized); 7903 } 7904 return normalized; 7905} 7906// Check if an incoming prop key is a declared emit event listener. 7907// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are 7908// both considered matched listeners. 7909function isEmitListener(options, key) { 7910 if (!options || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) { 7911 return false; 7912 } 7913 key = key.slice(2).replace(/Once$/, ''); 7914 return ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, key[0].toLowerCase() + key.slice(1)) || 7915 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key)) || 7916 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, key)); 7917} 7918 7919/** 7920 * mark the current rendering instance for asset resolution (e.g. 7921 * resolveComponent, resolveDirective) during render 7922 */ 7923let currentRenderingInstance = null; 7924let currentScopeId = null; 7925/** 7926 * Note: rendering calls maybe nested. The function returns the parent rendering 7927 * instance if present, which should be restored after the render is done: 7928 * 7929 * ```js 7930 * const prev = setCurrentRenderingInstance(i) 7931 * // ...render 7932 * setCurrentRenderingInstance(prev) 7933 * ``` 7934 */ 7935function setCurrentRenderingInstance(instance) { 7936 const prev = currentRenderingInstance; 7937 currentRenderingInstance = instance; 7938 currentScopeId = (instance && instance.type.__scopeId) || null; 7939 return prev; 7940} 7941/** 7942 * Set scope id when creating hoisted vnodes. 7943 * @private compiler helper 7944 */ 7945function pushScopeId(id) { 7946 currentScopeId = id; 7947} 7948/** 7949 * Technically we no longer need this after 3.0.8 but we need to keep the same 7950 * API for backwards compat w/ code generated by compilers. 7951 * @private 7952 */ 7953function popScopeId() { 7954 currentScopeId = null; 7955} 7956/** 7957 * Only for backwards compat 7958 * @private 7959 */ 7960const withScopeId = (_id) => withCtx; 7961/** 7962 * Wrap a slot function to memoize current rendering instance 7963 * @private compiler helper 7964 */ 7965function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot // false only 7966) { 7967 if (!ctx) 7968 return fn; 7969 // already normalized 7970 if (fn._n) { 7971 return fn; 7972 } 7973 const renderFnWithContext = (...args) => { 7974 // If a user calls a compiled slot inside a template expression (#1745), it 7975 // can mess up block tracking, so by default we disable block tracking and 7976 // force bail out when invoking a compiled slot (indicated by the ._d flag). 7977 // This isn't necessary if rendering a compiled `<slot>`, so we flip the 7978 // ._d flag off when invoking the wrapped fn inside `renderSlot`. 7979 if (renderFnWithContext._d) { 7980 setBlockTracking(-1); 7981 } 7982 const prevInstance = setCurrentRenderingInstance(ctx); 7983 let res; 7984 try { 7985 res = fn(...args); 7986 } 7987 finally { 7988 setCurrentRenderingInstance(prevInstance); 7989 if (renderFnWithContext._d) { 7990 setBlockTracking(1); 7991 } 7992 } 7993 if (true) { 7994 devtoolsComponentUpdated(ctx); 7995 } 7996 return res; 7997 }; 7998 // mark normalized to avoid duplicated wrapping 7999 renderFnWithContext._n = true; 8000 // mark this as compiled by default 8001 // this is used in vnode.ts -> normalizeChildren() to set the slot 8002 // rendering flag. 8003 renderFnWithContext._c = true; 8004 // disable block tracking by default 8005 renderFnWithContext._d = true; 8006 return renderFnWithContext; 8007} 8008 8009/** 8010 * dev only flag to track whether $attrs was used during render. 8011 * If $attrs was used during render then the warning for failed attrs 8012 * fallthrough can be suppressed. 8013 */ 8014let accessedAttrs = false; 8015function markAttrsAccessed() { 8016 accessedAttrs = true; 8017} 8018function renderComponentRoot(instance) { 8019 const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, data, setupState, ctx, inheritAttrs } = instance; 8020 let result; 8021 let fallthroughAttrs; 8022 const prev = setCurrentRenderingInstance(instance); 8023 if ((true)) { 8024 accessedAttrs = false; 8025 } 8026 try { 8027 if (vnode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */) { 8028 // withProxy is a proxy with a different `has` trap only for 8029 // runtime-compiled render functions using `with` block. 8030 const proxyToUse = withProxy || proxy; 8031 result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx)); 8032 fallthroughAttrs = attrs; 8033 } 8034 else { 8035 // functional 8036 const render = Component; 8037 // in dev, mark attrs accessed if optional props (attrs === props) 8038 if (( true) && attrs === props) { 8039 markAttrsAccessed(); 8040 } 8041 result = normalizeVNode(render.length > 1 8042 ? render(props, ( true) 8043 ? { 8044 get attrs() { 8045 markAttrsAccessed(); 8046 return attrs; 8047 }, 8048 slots, 8049 emit 8050 } 8051 : 0) 8052 : render(props, null /* we know it doesn't need it */)); 8053 fallthroughAttrs = Component.props 8054 ? attrs 8055 : getFunctionalFallthrough(attrs); 8056 } 8057 } 8058 catch (err) { 8059 blockStack.length = 0; 8060 handleError(err, instance, 1 /* ErrorCodes.RENDER_FUNCTION */); 8061 result = createVNode(Comment); 8062 } 8063 // attr merging 8064 // in dev mode, comments are preserved, and it's possible for a template 8065 // to have comments along side the root element which makes it a fragment 8066 let root = result; 8067 let setRoot = undefined; 8068 if (( true) && 8069 result.patchFlag > 0 && 8070 result.patchFlag & 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */) { 8071 [root, setRoot] = getChildRoot(result); 8072 } 8073 if (fallthroughAttrs && inheritAttrs !== false) { 8074 const keys = Object.keys(fallthroughAttrs); 8075 const { shapeFlag } = root; 8076 if (keys.length) { 8077 if (shapeFlag & (1 /* ShapeFlags.ELEMENT */ | 6 /* ShapeFlags.COMPONENT */)) { 8078 if (propsOptions && keys.some(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)) { 8079 // If a v-model listener (onUpdate:xxx) has a corresponding declared 8080 // prop, it indicates this component expects to handle v-model and 8081 // it should not fallthrough. 8082 // related: #1543, #1643, #1989 8083 fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions); 8084 } 8085 root = cloneVNode(root, fallthroughAttrs); 8086 } 8087 else if (( true) && !accessedAttrs && root.type !== Comment) { 8088 const allAttrs = Object.keys(attrs); 8089 const eventAttrs = []; 8090 const extraAttrs = []; 8091 for (let i = 0, l = allAttrs.length; i < l; i++) { 8092 const key = allAttrs[i]; 8093 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) { 8094 // ignore v-model handlers when they fail to fallthrough 8095 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)(key)) { 8096 // remove `on`, lowercase first letter to reflect event casing 8097 // accurately 8098 eventAttrs.push(key[2].toLowerCase() + key.slice(3)); 8099 } 8100 } 8101 else { 8102 extraAttrs.push(key); 8103 } 8104 } 8105 if (extraAttrs.length) { 8106 warn(`Extraneous non-props attributes (` + 8107 `${extraAttrs.join(', ')}) ` + 8108 `were passed to component but could not be automatically inherited ` + 8109 `because component renders fragment or text root nodes.`); 8110 } 8111 if (eventAttrs.length) { 8112 warn(`Extraneous non-emits event listeners (` + 8113 `${eventAttrs.join(', ')}) ` + 8114 `were passed to component but could not be automatically inherited ` + 8115 `because component renders fragment or text root nodes. ` + 8116 `If the listener is intended to be a component custom event listener only, ` + 8117 `declare it using the "emits" option.`); 8118 } 8119 } 8120 } 8121 } 8122 // inherit directives 8123 if (vnode.dirs) { 8124 if (( true) && !isElementRoot(root)) { 8125 warn(`Runtime directive used on component with non-element root node. ` + 8126 `The directives will not function as intended.`); 8127 } 8128 // clone before mutating since the root may be a hoisted vnode 8129 root = cloneVNode(root); 8130 root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs; 8131 } 8132 // inherit transition data 8133 if (vnode.transition) { 8134 if (( true) && !isElementRoot(root)) { 8135 warn(`Component inside <Transition> renders non-element root node ` + 8136 `that cannot be animated.`); 8137 } 8138 root.transition = vnode.transition; 8139 } 8140 if (( true) && setRoot) { 8141 setRoot(root); 8142 } 8143 else { 8144 result = root; 8145 } 8146 setCurrentRenderingInstance(prev); 8147 return result; 8148} 8149/** 8150 * dev only 8151 * In dev mode, template root level comments are rendered, which turns the 8152 * template into a fragment root, but we need to locate the single element 8153 * root for attrs and scope id processing. 8154 */ 8155const getChildRoot = (vnode) => { 8156 const rawChildren = vnode.children; 8157 const dynamicChildren = vnode.dynamicChildren; 8158 const childRoot = filterSingleRoot(rawChildren); 8159 if (!childRoot) { 8160 return [vnode, undefined]; 8161 } 8162 const index = rawChildren.indexOf(childRoot); 8163 const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1; 8164 const setRoot = (updatedRoot) => { 8165 rawChildren[index] = updatedRoot; 8166 if (dynamicChildren) { 8167 if (dynamicIndex > -1) { 8168 dynamicChildren[dynamicIndex] = updatedRoot; 8169 } 8170 else if (updatedRoot.patchFlag > 0) { 8171 vnode.dynamicChildren = [...dynamicChildren, updatedRoot]; 8172 } 8173 } 8174 }; 8175 return [normalizeVNode(childRoot), setRoot]; 8176}; 8177function filterSingleRoot(children) { 8178 let singleRoot; 8179 for (let i = 0; i < children.length; i++) { 8180 const child = children[i]; 8181 if (isVNode(child)) { 8182 // ignore user comment 8183 if (child.type !== Comment || child.children === 'v-if') { 8184 if (singleRoot) { 8185 // has more than 1 non-comment child, return now 8186 return; 8187 } 8188 else { 8189 singleRoot = child; 8190 } 8191 } 8192 } 8193 else { 8194 return; 8195 } 8196 } 8197 return singleRoot; 8198} 8199const getFunctionalFallthrough = (attrs) => { 8200 let res; 8201 for (const key in attrs) { 8202 if (key === 'class' || key === 'style' || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) { 8203 (res || (res = {}))[key] = attrs[key]; 8204 } 8205 } 8206 return res; 8207}; 8208const filterModelListeners = (attrs, props) => { 8209 const res = {}; 8210 for (const key in attrs) { 8211 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)(key) || !(key.slice(9) in props)) { 8212 res[key] = attrs[key]; 8213 } 8214 } 8215 return res; 8216}; 8217const isElementRoot = (vnode) => { 8218 return (vnode.shapeFlag & (6 /* ShapeFlags.COMPONENT */ | 1 /* ShapeFlags.ELEMENT */) || 8219 vnode.type === Comment // potential v-if branch switch 8220 ); 8221}; 8222function shouldUpdateComponent(prevVNode, nextVNode, optimized) { 8223 const { props: prevProps, children: prevChildren, component } = prevVNode; 8224 const { props: nextProps, children: nextChildren, patchFlag } = nextVNode; 8225 const emits = component.emitsOptions; 8226 // Parent component's render function was hot-updated. Since this may have 8227 // caused the child component's slots content to have changed, we need to 8228 // force the child to update as well. 8229 if (( true) && (prevChildren || nextChildren) && isHmrUpdating) { 8230 return true; 8231 } 8232 // force child update for runtime directive or transition on component vnode. 8233 if (nextVNode.dirs || nextVNode.transition) { 8234 return true; 8235 } 8236 if (optimized && patchFlag >= 0) { 8237 if (patchFlag & 1024 /* PatchFlags.DYNAMIC_SLOTS */) { 8238 // slot content that references values that might have changed, 8239 // e.g. in a v-for 8240 return true; 8241 } 8242 if (patchFlag & 16 /* PatchFlags.FULL_PROPS */) { 8243 if (!prevProps) { 8244 return !!nextProps; 8245 } 8246 // presence of this flag indicates props are always non-null 8247 return hasPropsChanged(prevProps, nextProps, emits); 8248 } 8249 else if (patchFlag & 8 /* PatchFlags.PROPS */) { 8250 const dynamicProps = nextVNode.dynamicProps; 8251 for (let i = 0; i < dynamicProps.length; i++) { 8252 const key = dynamicProps[i]; 8253 if (nextProps[key] !== prevProps[key] && 8254 !isEmitListener(emits, key)) { 8255 return true; 8256 } 8257 } 8258 } 8259 } 8260 else { 8261 // this path is only taken by manually written render functions 8262 // so presence of any children leads to a forced update 8263 if (prevChildren || nextChildren) { 8264 if (!nextChildren || !nextChildren.$stable) { 8265 return true; 8266 } 8267 } 8268 if (prevProps === nextProps) { 8269 return false; 8270 } 8271 if (!prevProps) { 8272 return !!nextProps; 8273 } 8274 if (!nextProps) { 8275 return true; 8276 } 8277 return hasPropsChanged(prevProps, nextProps, emits); 8278 } 8279 return false; 8280} 8281function hasPropsChanged(prevProps, nextProps, emitsOptions) { 8282 const nextKeys = Object.keys(nextProps); 8283 if (nextKeys.length !== Object.keys(prevProps).length) { 8284 return true; 8285 } 8286 for (let i = 0; i < nextKeys.length; i++) { 8287 const key = nextKeys[i]; 8288 if (nextProps[key] !== prevProps[key] && 8289 !isEmitListener(emitsOptions, key)) { 8290 return true; 8291 } 8292 } 8293 return false; 8294} 8295function updateHOCHostEl({ vnode, parent }, el // HostNode 8296) { 8297 while (parent && parent.subTree === vnode) { 8298 (vnode = parent.vnode).el = el; 8299 parent = parent.parent; 8300 } 8301} 8302 8303const isSuspense = (type) => type.__isSuspense; 8304// Suspense exposes a component-like API, and is treated like a component 8305// in the compiler, but internally it's a special built-in type that hooks 8306// directly into the renderer. 8307const SuspenseImpl = { 8308 name: 'Suspense', 8309 // In order to make Suspense tree-shakable, we need to avoid importing it 8310 // directly in the renderer. The renderer checks for the __isSuspense flag 8311 // on a vnode's type and calls the `process` method, passing in renderer 8312 // internals. 8313 __isSuspense: true, 8314 process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, 8315 // platform-specific impl passed from renderer 8316 rendererInternals) { 8317 if (n1 == null) { 8318 mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals); 8319 } 8320 else { 8321 patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, rendererInternals); 8322 } 8323 }, 8324 hydrate: hydrateSuspense, 8325 create: createSuspenseBoundary, 8326 normalize: normalizeSuspenseChildren 8327}; 8328// Force-casted public typing for h and TSX props inference 8329const Suspense = (SuspenseImpl 8330 ); 8331function triggerEvent(vnode, name) { 8332 const eventListener = vnode.props && vnode.props[name]; 8333 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(eventListener)) { 8334 eventListener(); 8335 } 8336} 8337function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) { 8338 const { p: patch, o: { createElement } } = rendererInternals; 8339 const hiddenContainer = createElement('div'); 8340 const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals)); 8341 // start mounting the content subtree in an off-dom container 8342 patch(null, (suspense.pendingBranch = vnode.ssContent), hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds); 8343 // now check if we have encountered any async deps 8344 if (suspense.deps > 0) { 8345 // has async 8346 // invoke @fallback event 8347 triggerEvent(vnode, 'onPending'); 8348 triggerEvent(vnode, 'onFallback'); 8349 // mount the fallback tree 8350 patch(null, vnode.ssFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context 8351 isSVG, slotScopeIds); 8352 setActiveBranch(suspense, vnode.ssFallback); 8353 } 8354 else { 8355 // Suspense has no async deps. Just resolve. 8356 suspense.resolve(); 8357 } 8358} 8359function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) { 8360 const suspense = (n2.suspense = n1.suspense); 8361 suspense.vnode = n2; 8362 n2.el = n1.el; 8363 const newBranch = n2.ssContent; 8364 const newFallback = n2.ssFallback; 8365 const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense; 8366 if (pendingBranch) { 8367 suspense.pendingBranch = newBranch; 8368 if (isSameVNodeType(newBranch, pendingBranch)) { 8369 // same root type but content may have changed. 8370 patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); 8371 if (suspense.deps <= 0) { 8372 suspense.resolve(); 8373 } 8374 else if (isInFallback) { 8375 patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context 8376 isSVG, slotScopeIds, optimized); 8377 setActiveBranch(suspense, newFallback); 8378 } 8379 } 8380 else { 8381 // toggled before pending tree is resolved 8382 suspense.pendingId++; 8383 if (isHydrating) { 8384 // if toggled before hydration is finished, the current DOM tree is 8385 // no longer valid. set it as the active branch so it will be unmounted 8386 // when resolved 8387 suspense.isHydrating = false; 8388 suspense.activeBranch = pendingBranch; 8389 } 8390 else { 8391 unmount(pendingBranch, parentComponent, suspense); 8392 } 8393 // increment pending ID. this is used to invalidate async callbacks 8394 // reset suspense state 8395 suspense.deps = 0; 8396 // discard effects from pending branch 8397 suspense.effects.length = 0; 8398 // discard previous container 8399 suspense.hiddenContainer = createElement('div'); 8400 if (isInFallback) { 8401 // already in fallback state 8402 patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); 8403 if (suspense.deps <= 0) { 8404 suspense.resolve(); 8405 } 8406 else { 8407 patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context 8408 isSVG, slotScopeIds, optimized); 8409 setActiveBranch(suspense, newFallback); 8410 } 8411 } 8412 else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { 8413 // toggled "back" to current active branch 8414 patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); 8415 // force resolve 8416 suspense.resolve(true); 8417 } 8418 else { 8419 // switched to a 3rd branch 8420 patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); 8421 if (suspense.deps <= 0) { 8422 suspense.resolve(); 8423 } 8424 } 8425 } 8426 } 8427 else { 8428 if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { 8429 // root did not change, just normal patch 8430 patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); 8431 setActiveBranch(suspense, newBranch); 8432 } 8433 else { 8434 // root node toggled 8435 // invoke @pending event 8436 triggerEvent(n2, 'onPending'); 8437 // mount pending branch in off-dom container 8438 suspense.pendingBranch = newBranch; 8439 suspense.pendingId++; 8440 patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); 8441 if (suspense.deps <= 0) { 8442 // incoming branch has no async deps, resolve now. 8443 suspense.resolve(); 8444 } 8445 else { 8446 const { timeout, pendingId } = suspense; 8447 if (timeout > 0) { 8448 setTimeout(() => { 8449 if (suspense.pendingId === pendingId) { 8450 suspense.fallback(newFallback); 8451 } 8452 }, timeout); 8453 } 8454 else if (timeout === 0) { 8455 suspense.fallback(newFallback); 8456 } 8457 } 8458 } 8459 } 8460} 8461let hasWarned = false; 8462function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) { 8463 /* istanbul ignore if */ 8464 if ( true && !hasWarned) { 8465 hasWarned = true; 8466 // @ts-ignore `console.info` cannot be null error 8467 console[console.info ? 'info' : 'log'](`<Suspense> is an experimental feature and its API will likely change.`); 8468 } 8469 const { p: patch, m: move, um: unmount, n: next, o: { parentNode, remove } } = rendererInternals; 8470 const timeout = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(vnode.props && vnode.props.timeout); 8471 const suspense = { 8472 vnode, 8473 parent, 8474 parentComponent, 8475 isSVG, 8476 container, 8477 hiddenContainer, 8478 anchor, 8479 deps: 0, 8480 pendingId: 0, 8481 timeout: typeof timeout === 'number' ? timeout : -1, 8482 activeBranch: null, 8483 pendingBranch: null, 8484 isInFallback: true, 8485 isHydrating, 8486 isUnmounted: false, 8487 effects: [], 8488 resolve(resume = false) { 8489 if ((true)) { 8490 if (!resume && !suspense.pendingBranch) { 8491 throw new Error(`suspense.resolve() is called without a pending branch.`); 8492 } 8493 if (suspense.isUnmounted) { 8494 throw new Error(`suspense.resolve() is called on an already unmounted suspense boundary.`); 8495 } 8496 } 8497 const { vnode, activeBranch, pendingBranch, pendingId, effects, parentComponent, container } = suspense; 8498 if (suspense.isHydrating) { 8499 suspense.isHydrating = false; 8500 } 8501 else if (!resume) { 8502 const delayEnter = activeBranch && 8503 pendingBranch.transition && 8504 pendingBranch.transition.mode === 'out-in'; 8505 if (delayEnter) { 8506 activeBranch.transition.afterLeave = () => { 8507 if (pendingId === suspense.pendingId) { 8508 move(pendingBranch, container, anchor, 0 /* MoveType.ENTER */); 8509 } 8510 }; 8511 } 8512 // this is initial anchor on mount 8513 let { anchor } = suspense; 8514 // unmount current active tree 8515 if (activeBranch) { 8516 // if the fallback tree was mounted, it may have been moved 8517 // as part of a parent suspense. get the latest anchor for insertion 8518 anchor = next(activeBranch); 8519 unmount(activeBranch, parentComponent, suspense, true); 8520 } 8521 if (!delayEnter) { 8522 // move content from off-dom container to actual container 8523 move(pendingBranch, container, anchor, 0 /* MoveType.ENTER */); 8524 } 8525 } 8526 setActiveBranch(suspense, pendingBranch); 8527 suspense.pendingBranch = null; 8528 suspense.isInFallback = false; 8529 // flush buffered effects 8530 // check if there is a pending parent suspense 8531 let parent = suspense.parent; 8532 let hasUnresolvedAncestor = false; 8533 while (parent) { 8534 if (parent.pendingBranch) { 8535 // found a pending parent suspense, merge buffered post jobs 8536 // into that parent 8537 parent.effects.push(...effects); 8538 hasUnresolvedAncestor = true; 8539 break; 8540 } 8541 parent = parent.parent; 8542 } 8543 // no pending parent suspense, flush all jobs 8544 if (!hasUnresolvedAncestor) { 8545 queuePostFlushCb(effects); 8546 } 8547 suspense.effects = []; 8548 // invoke @resolve event 8549 triggerEvent(vnode, 'onResolve'); 8550 }, 8551 fallback(fallbackVNode) { 8552 if (!suspense.pendingBranch) { 8553 return; 8554 } 8555 const { vnode, activeBranch, parentComponent, container, isSVG } = suspense; 8556 // invoke @fallback event 8557 triggerEvent(vnode, 'onFallback'); 8558 const anchor = next(activeBranch); 8559 const mountFallback = () => { 8560 if (!suspense.isInFallback) { 8561 return; 8562 } 8563 // mount the fallback tree 8564 patch(null, fallbackVNode, container, anchor, parentComponent, null, // fallback tree will not have suspense context 8565 isSVG, slotScopeIds, optimized); 8566 setActiveBranch(suspense, fallbackVNode); 8567 }; 8568 const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === 'out-in'; 8569 if (delayEnter) { 8570 activeBranch.transition.afterLeave = mountFallback; 8571 } 8572 suspense.isInFallback = true; 8573 // unmount current active branch 8574 unmount(activeBranch, parentComponent, null, // no suspense so unmount hooks fire now 8575 true // shouldRemove 8576 ); 8577 if (!delayEnter) { 8578 mountFallback(); 8579 } 8580 }, 8581 move(container, anchor, type) { 8582 suspense.activeBranch && 8583 move(suspense.activeBranch, container, anchor, type); 8584 suspense.container = container; 8585 }, 8586 next() { 8587 return suspense.activeBranch && next(suspense.activeBranch); 8588 }, 8589 registerDep(instance, setupRenderEffect) { 8590 const isInPendingSuspense = !!suspense.pendingBranch; 8591 if (isInPendingSuspense) { 8592 suspense.deps++; 8593 } 8594 const hydratedEl = instance.vnode.el; 8595 instance 8596 .asyncDep.catch(err => { 8597 handleError(err, instance, 0 /* ErrorCodes.SETUP_FUNCTION */); 8598 }) 8599 .then(asyncSetupResult => { 8600 // retry when the setup() promise resolves. 8601 // component may have been unmounted before resolve. 8602 if (instance.isUnmounted || 8603 suspense.isUnmounted || 8604 suspense.pendingId !== instance.suspenseId) { 8605 return; 8606 } 8607 // retry from this component 8608 instance.asyncResolved = true; 8609 const { vnode } = instance; 8610 if ((true)) { 8611 pushWarningContext(vnode); 8612 } 8613 handleSetupResult(instance, asyncSetupResult, false); 8614 if (hydratedEl) { 8615 // vnode may have been replaced if an update happened before the 8616 // async dep is resolved. 8617 vnode.el = hydratedEl; 8618 } 8619 const placeholder = !hydratedEl && instance.subTree.el; 8620 setupRenderEffect(instance, vnode, 8621 // component may have been moved before resolve. 8622 // if this is not a hydration, instance.subTree will be the comment 8623 // placeholder. 8624 parentNode(hydratedEl || instance.subTree.el), 8625 // anchor will not be used if this is hydration, so only need to 8626 // consider the comment placeholder case. 8627 hydratedEl ? null : next(instance.subTree), suspense, isSVG, optimized); 8628 if (placeholder) { 8629 remove(placeholder); 8630 } 8631 updateHOCHostEl(instance, vnode.el); 8632 if ((true)) { 8633 popWarningContext(); 8634 } 8635 // only decrease deps count if suspense is not already resolved 8636 if (isInPendingSuspense && --suspense.deps === 0) { 8637 suspense.resolve(); 8638 } 8639 }); 8640 }, 8641 unmount(parentSuspense, doRemove) { 8642 suspense.isUnmounted = true; 8643 if (suspense.activeBranch) { 8644 unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove); 8645 } 8646 if (suspense.pendingBranch) { 8647 unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove); 8648 } 8649 } 8650 }; 8651 return suspense; 8652} 8653function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) { 8654 /* eslint-disable no-restricted-globals */ 8655 const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, slotScopeIds, optimized, rendererInternals, true /* hydrating */)); 8656 // there are two possible scenarios for server-rendered suspense: 8657 // - success: ssr content should be fully resolved 8658 // - failure: ssr content should be the fallback branch. 8659 // however, on the client we don't really know if it has failed or not 8660 // attempt to hydrate the DOM assuming it has succeeded, but we still 8661 // need to construct a suspense boundary first 8662 const result = hydrateNode(node, (suspense.pendingBranch = vnode.ssContent), parentComponent, suspense, slotScopeIds, optimized); 8663 if (suspense.deps === 0) { 8664 suspense.resolve(); 8665 } 8666 return result; 8667 /* eslint-enable no-restricted-globals */ 8668} 8669function normalizeSuspenseChildren(vnode) { 8670 const { shapeFlag, children } = vnode; 8671 const isSlotChildren = shapeFlag & 32 /* ShapeFlags.SLOTS_CHILDREN */; 8672 vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children); 8673 vnode.ssFallback = isSlotChildren 8674 ? normalizeSuspenseSlot(children.fallback) 8675 : createVNode(Comment); 8676} 8677function normalizeSuspenseSlot(s) { 8678 let block; 8679 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(s)) { 8680 const trackBlock = isBlockTreeEnabled && s._c; 8681 if (trackBlock) { 8682 // disableTracking: false 8683 // allow block tracking for compiled slots 8684 // (see ./componentRenderContext.ts) 8685 s._d = false; 8686 openBlock(); 8687 } 8688 s = s(); 8689 if (trackBlock) { 8690 s._d = true; 8691 block = currentBlock; 8692 closeBlock(); 8693 } 8694 } 8695 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(s)) { 8696 const singleChild = filterSingleRoot(s); 8697 if (( true) && !singleChild) { 8698 warn(`<Suspense> slots expect a single root node.`); 8699 } 8700 s = singleChild; 8701 } 8702 s = normalizeVNode(s); 8703 if (block && !s.dynamicChildren) { 8704 s.dynamicChildren = block.filter(c => c !== s); 8705 } 8706 return s; 8707} 8708function queueEffectWithSuspense(fn, suspense) { 8709 if (suspense && suspense.pendingBranch) { 8710 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(fn)) { 8711 suspense.effects.push(...fn); 8712 } 8713 else { 8714 suspense.effects.push(fn); 8715 } 8716 } 8717 else { 8718 queuePostFlushCb(fn); 8719 } 8720} 8721function setActiveBranch(suspense, branch) { 8722 suspense.activeBranch = branch; 8723 const { vnode, parentComponent } = suspense; 8724 const el = (vnode.el = branch.el); 8725 // in case suspense is the root node of a component, 8726 // recursively update the HOC el 8727 if (parentComponent && parentComponent.subTree === vnode) { 8728 parentComponent.vnode.el = el; 8729 updateHOCHostEl(parentComponent, el); 8730 } 8731} 8732 8733function provide(key, value) { 8734 if (!currentInstance) { 8735 if ((true)) { 8736 warn(`provide() can only be used inside setup().`); 8737 } 8738 } 8739 else { 8740 let provides = currentInstance.provides; 8741 // by default an instance inherits its parent's provides object 8742 // but when it needs to provide values of its own, it creates its 8743 // own provides object using parent provides object as prototype. 8744 // this way in `inject` we can simply look up injections from direct 8745 // parent and let the prototype chain do the work. 8746 const parentProvides = currentInstance.parent && currentInstance.parent.provides; 8747 if (parentProvides === provides) { 8748 provides = currentInstance.provides = Object.create(parentProvides); 8749 } 8750 // TS doesn't allow symbol as index type 8751 provides[key] = value; 8752 } 8753} 8754function inject(key, defaultValue, treatDefaultAsFactory = false) { 8755 // fallback to `currentRenderingInstance` so that this can be called in 8756 // a functional component 8757 const instance = currentInstance || currentRenderingInstance; 8758 if (instance) { 8759 // #2400 8760 // to support `app.use` plugins, 8761 // fallback to appContext's `provides` if the instance is at root 8762 const provides = instance.parent == null 8763 ? instance.vnode.appContext && instance.vnode.appContext.provides 8764 : instance.parent.provides; 8765 if (provides && key in provides) { 8766 // TS doesn't allow symbol as index type 8767 return provides[key]; 8768 } 8769 else if (arguments.length > 1) { 8770 return treatDefaultAsFactory && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(defaultValue) 8771 ? defaultValue.call(instance.proxy) 8772 : defaultValue; 8773 } 8774 else if ((true)) { 8775 warn(`injection "${String(key)}" not found.`); 8776 } 8777 } 8778 else if ((true)) { 8779 warn(`inject() can only be used inside setup() or functional components.`); 8780 } 8781} 8782 8783// Simple effect. 8784function watchEffect(effect, options) { 8785 return doWatch(effect, null, options); 8786} 8787function watchPostEffect(effect, options) { 8788 return doWatch(effect, null, (( true) 8789 ? Object.assign(Object.assign({}, options), { flush: 'post' }) : 0)); 8790} 8791function watchSyncEffect(effect, options) { 8792 return doWatch(effect, null, (( true) 8793 ? Object.assign(Object.assign({}, options), { flush: 'sync' }) : 0)); 8794} 8795// initial value for watchers to trigger on undefined initial values 8796const INITIAL_WATCHER_VALUE = {}; 8797// implementation 8798function watch(source, cb, options) { 8799 if (( true) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(cb)) { 8800 warn(`\`watch(fn, options?)\` signature has been moved to a separate API. ` + 8801 `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` + 8802 `supports \`watch(source, cb, options?) signature.`); 8803 } 8804 return doWatch(source, cb, options); 8805} 8806function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) { 8807 if (( true) && !cb) { 8808 if (immediate !== undefined) { 8809 warn(`watch() "immediate" option is only respected when using the ` + 8810 `watch(source, callback, options?) signature.`); 8811 } 8812 if (deep !== undefined) { 8813 warn(`watch() "deep" option is only respected when using the ` + 8814 `watch(source, callback, options?) signature.`); 8815 } 8816 } 8817 const warnInvalidSource = (s) => { 8818 warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` + 8819 `a reactive object, or an array of these types.`); 8820 }; 8821 const instance = currentInstance; 8822 let getter; 8823 let forceTrigger = false; 8824 let isMultiSource = false; 8825 if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(source)) { 8826 getter = () => source.value; 8827 forceTrigger = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(source); 8828 } 8829 else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive)(source)) { 8830 getter = () => source; 8831 deep = true; 8832 } 8833 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(source)) { 8834 isMultiSource = true; 8835 forceTrigger = source.some(s => (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive)(s) || (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(s)); 8836 getter = () => source.map(s => { 8837 if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(s)) { 8838 return s.value; 8839 } 8840 else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive)(s)) { 8841 return traverse(s); 8842 } 8843 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(s)) { 8844 return callWithErrorHandling(s, instance, 2 /* ErrorCodes.WATCH_GETTER */); 8845 } 8846 else { 8847 ( true) && warnInvalidSource(s); 8848 } 8849 }); 8850 } 8851 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(source)) { 8852 if (cb) { 8853 // getter with cb 8854 getter = () => callWithErrorHandling(source, instance, 2 /* ErrorCodes.WATCH_GETTER */); 8855 } 8856 else { 8857 // no cb -> simple effect 8858 getter = () => { 8859 if (instance && instance.isUnmounted) { 8860 return; 8861 } 8862 if (cleanup) { 8863 cleanup(); 8864 } 8865 return callWithAsyncErrorHandling(source, instance, 3 /* ErrorCodes.WATCH_CALLBACK */, [onCleanup]); 8866 }; 8867 } 8868 } 8869 else { 8870 getter = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP; 8871 ( true) && warnInvalidSource(source); 8872 } 8873 if (cb && deep) { 8874 const baseGetter = getter; 8875 getter = () => traverse(baseGetter()); 8876 } 8877 let cleanup; 8878 let onCleanup = (fn) => { 8879 cleanup = effect.onStop = () => { 8880 callWithErrorHandling(fn, instance, 4 /* ErrorCodes.WATCH_CLEANUP */); 8881 }; 8882 }; 8883 // in SSR there is no need to setup an actual effect, and it should be noop 8884 // unless it's eager or sync flush 8885 let ssrCleanup; 8886 if (isInSSRComponentSetup) { 8887 // we will also not call the invalidate callback (+ runner is not set up) 8888 onCleanup = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP; 8889 if (!cb) { 8890 getter(); 8891 } 8892 else if (immediate) { 8893 callWithAsyncErrorHandling(cb, instance, 3 /* ErrorCodes.WATCH_CALLBACK */, [ 8894 getter(), 8895 isMultiSource ? [] : undefined, 8896 onCleanup 8897 ]); 8898 } 8899 if (flush === 'sync') { 8900 const ctx = useSSRContext(); 8901 ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []); 8902 } 8903 else { 8904 return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP; 8905 } 8906 } 8907 let oldValue = isMultiSource 8908 ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) 8909 : INITIAL_WATCHER_VALUE; 8910 const job = () => { 8911 if (!effect.active) { 8912 return; 8913 } 8914 if (cb) { 8915 // watch(source, cb) 8916 const newValue = effect.run(); 8917 if (deep || 8918 forceTrigger || 8919 (isMultiSource 8920 ? newValue.some((v, i) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(v, oldValue[i])) 8921 : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(newValue, oldValue)) || 8922 (false )) { 8923 // cleanup before running cb again 8924 if (cleanup) { 8925 cleanup(); 8926 } 8927 callWithAsyncErrorHandling(cb, instance, 3 /* ErrorCodes.WATCH_CALLBACK */, [ 8928 newValue, 8929 // pass undefined as the old value when it's changed for the first time 8930 oldValue === INITIAL_WATCHER_VALUE 8931 ? undefined 8932 : (isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE) 8933 ? [] 8934 : oldValue, 8935 onCleanup 8936 ]); 8937 oldValue = newValue; 8938 } 8939 } 8940 else { 8941 // watchEffect 8942 effect.run(); 8943 } 8944 }; 8945 // important: mark the job as a watcher callback so that scheduler knows 8946 // it is allowed to self-trigger (#1727) 8947 job.allowRecurse = !!cb; 8948 let scheduler; 8949 if (flush === 'sync') { 8950 scheduler = job; // the scheduler function gets called directly 8951 } 8952 else if (flush === 'post') { 8953 scheduler = () => queuePostRenderEffect(job, instance && instance.suspense); 8954 } 8955 else { 8956 // default: 'pre' 8957 job.pre = true; 8958 if (instance) 8959 job.id = instance.uid; 8960 scheduler = () => queueJob(job); 8961 } 8962 const effect = new _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect(getter, scheduler); 8963 if ((true)) { 8964 effect.onTrack = onTrack; 8965 effect.onTrigger = onTrigger; 8966 } 8967 // initial run 8968 if (cb) { 8969 if (immediate) { 8970 job(); 8971 } 8972 else { 8973 oldValue = effect.run(); 8974 } 8975 } 8976 else if (flush === 'post') { 8977 queuePostRenderEffect(effect.run.bind(effect), instance && instance.suspense); 8978 } 8979 else { 8980 effect.run(); 8981 } 8982 const unwatch = () => { 8983 effect.stop(); 8984 if (instance && instance.scope) { 8985 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.remove)(instance.scope.effects, effect); 8986 } 8987 }; 8988 if (ssrCleanup) 8989 ssrCleanup.push(unwatch); 8990 return unwatch; 8991} 8992// this.$watch 8993function instanceWatch(source, value, options) { 8994 const publicThis = this.proxy; 8995 const getter = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(source) 8996 ? source.includes('.') 8997 ? createPathGetter(publicThis, source) 8998 : () => publicThis[source] 8999 : source.bind(publicThis, publicThis); 9000 let cb; 9001 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) { 9002 cb = value; 9003 } 9004 else { 9005 cb = value.handler; 9006 options = value; 9007 } 9008 const cur = currentInstance; 9009 setCurrentInstance(this); 9010 const res = doWatch(getter, cb.bind(publicThis), options); 9011 if (cur) { 9012 setCurrentInstance(cur); 9013 } 9014 else { 9015 unsetCurrentInstance(); 9016 } 9017 return res; 9018} 9019function createPathGetter(ctx, path) { 9020 const segments = path.split('.'); 9021 return () => { 9022 let cur = ctx; 9023 for (let i = 0; i < segments.length && cur; i++) { 9024 cur = cur[segments[i]]; 9025 } 9026 return cur; 9027 }; 9028} 9029function traverse(value, seen) { 9030 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(value) || value["__v_skip" /* ReactiveFlags.SKIP */]) { 9031 return value; 9032 } 9033 seen = seen || new Set(); 9034 if (seen.has(value)) { 9035 return value; 9036 } 9037 seen.add(value); 9038 if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(value)) { 9039 traverse(value.value, seen); 9040 } 9041 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) { 9042 for (let i = 0; i < value.length; i++) { 9043 traverse(value[i], seen); 9044 } 9045 } 9046 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isMap)(value)) { 9047 value.forEach((v) => { 9048 traverse(v, seen); 9049 }); 9050 } 9051 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPlainObject)(value)) { 9052 for (const key in value) { 9053 traverse(value[key], seen); 9054 } 9055 } 9056 return value; 9057} 9058 9059function useTransitionState() { 9060 const state = { 9061 isMounted: false, 9062 isLeaving: false, 9063 isUnmounting: false, 9064 leavingVNodes: new Map() 9065 }; 9066 onMounted(() => { 9067 state.isMounted = true; 9068 }); 9069 onBeforeUnmount(() => { 9070 state.isUnmounting = true; 9071 }); 9072 return state; 9073} 9074const TransitionHookValidator = [Function, Array]; 9075const BaseTransitionImpl = { 9076 name: `BaseTransition`, 9077 props: { 9078 mode: String, 9079 appear: Boolean, 9080 persisted: Boolean, 9081 // enter 9082 onBeforeEnter: TransitionHookValidator, 9083 onEnter: TransitionHookValidator, 9084 onAfterEnter: TransitionHookValidator, 9085 onEnterCancelled: TransitionHookValidator, 9086 // leave 9087 onBeforeLeave: TransitionHookValidator, 9088 onLeave: TransitionHookValidator, 9089 onAfterLeave: TransitionHookValidator, 9090 onLeaveCancelled: TransitionHookValidator, 9091 // appear 9092 onBeforeAppear: TransitionHookValidator, 9093 onAppear: TransitionHookValidator, 9094 onAfterAppear: TransitionHookValidator, 9095 onAppearCancelled: TransitionHookValidator 9096 }, 9097 setup(props, { slots }) { 9098 const instance = getCurrentInstance(); 9099 const state = useTransitionState(); 9100 let prevTransitionKey; 9101 return () => { 9102 const children = slots.default && getTransitionRawChildren(slots.default(), true); 9103 if (!children || !children.length) { 9104 return; 9105 } 9106 let child = children[0]; 9107 if (children.length > 1) { 9108 let hasFound = false; 9109 // locate first non-comment child 9110 for (const c of children) { 9111 if (c.type !== Comment) { 9112 if (( true) && hasFound) { 9113 // warn more than one non-comment child 9114 warn('<transition> can only be used on a single element or component. ' + 9115 'Use <transition-group> for lists.'); 9116 break; 9117 } 9118 child = c; 9119 hasFound = true; 9120 if (false) 9121 {} 9122 } 9123 } 9124 } 9125 // there's no need to track reactivity for these props so use the raw 9126 // props for a bit better perf 9127 const rawProps = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props); 9128 const { mode } = rawProps; 9129 // check mode 9130 if (( true) && 9131 mode && 9132 mode !== 'in-out' && 9133 mode !== 'out-in' && 9134 mode !== 'default') { 9135 warn(`invalid <transition> mode: ${mode}`); 9136 } 9137 if (state.isLeaving) { 9138 return emptyPlaceholder(child); 9139 } 9140 // in the case of <transition><keep-alive/></transition>, we need to 9141 // compare the type of the kept-alive children. 9142 const innerChild = getKeepAliveChild(child); 9143 if (!innerChild) { 9144 return emptyPlaceholder(child); 9145 } 9146 const enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance); 9147 setTransitionHooks(innerChild, enterHooks); 9148 const oldChild = instance.subTree; 9149 const oldInnerChild = oldChild && getKeepAliveChild(oldChild); 9150 let transitionKeyChanged = false; 9151 const { getTransitionKey } = innerChild.type; 9152 if (getTransitionKey) { 9153 const key = getTransitionKey(); 9154 if (prevTransitionKey === undefined) { 9155 prevTransitionKey = key; 9156 } 9157 else if (key !== prevTransitionKey) { 9158 prevTransitionKey = key; 9159 transitionKeyChanged = true; 9160 } 9161 } 9162 // handle mode 9163 if (oldInnerChild && 9164 oldInnerChild.type !== Comment && 9165 (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) { 9166 const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance); 9167 // update old tree's hooks in case of dynamic transition 9168 setTransitionHooks(oldInnerChild, leavingHooks); 9169 // switching between different views 9170 if (mode === 'out-in') { 9171 state.isLeaving = true; 9172 // return placeholder node and queue update when leave finishes 9173 leavingHooks.afterLeave = () => { 9174 state.isLeaving = false; 9175 // #6835 9176 // it also needs to be updated when active is undefined 9177 if (instance.update.active !== false) { 9178 instance.update(); 9179 } 9180 }; 9181 return emptyPlaceholder(child); 9182 } 9183 else if (mode === 'in-out' && innerChild.type !== Comment) { 9184 leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => { 9185 const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild); 9186 leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild; 9187 // early removal callback 9188 el._leaveCb = () => { 9189 earlyRemove(); 9190 el._leaveCb = undefined; 9191 delete enterHooks.delayedLeave; 9192 }; 9193 enterHooks.delayedLeave = delayedLeave; 9194 }; 9195 } 9196 } 9197 return child; 9198 }; 9199 } 9200}; 9201// export the public type for h/tsx inference 9202// also to avoid inline import() in generated d.ts files 9203const BaseTransition = BaseTransitionImpl; 9204function getLeavingNodesForType(state, vnode) { 9205 const { leavingVNodes } = state; 9206 let leavingVNodesCache = leavingVNodes.get(vnode.type); 9207 if (!leavingVNodesCache) { 9208 leavingVNodesCache = Object.create(null); 9209 leavingVNodes.set(vnode.type, leavingVNodesCache); 9210 } 9211 return leavingVNodesCache; 9212} 9213// The transition hooks are attached to the vnode as vnode.transition 9214// and will be called at appropriate timing in the renderer. 9215function resolveTransitionHooks(vnode, props, state, instance) { 9216 const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props; 9217 const key = String(vnode.key); 9218 const leavingVNodesCache = getLeavingNodesForType(state, vnode); 9219 const callHook = (hook, args) => { 9220 hook && 9221 callWithAsyncErrorHandling(hook, instance, 9 /* ErrorCodes.TRANSITION_HOOK */, args); 9222 }; 9223 const callAsyncHook = (hook, args) => { 9224 const done = args[1]; 9225 callHook(hook, args); 9226 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook)) { 9227 if (hook.every(hook => hook.length <= 1)) 9228 done(); 9229 } 9230 else if (hook.length <= 1) { 9231 done(); 9232 } 9233 }; 9234 const hooks = { 9235 mode, 9236 persisted, 9237 beforeEnter(el) { 9238 let hook = onBeforeEnter; 9239 if (!state.isMounted) { 9240 if (appear) { 9241 hook = onBeforeAppear || onBeforeEnter; 9242 } 9243 else { 9244 return; 9245 } 9246 } 9247 // for same element (v-show) 9248 if (el._leaveCb) { 9249 el._leaveCb(true /* cancelled */); 9250 } 9251 // for toggled element with same key (v-if) 9252 const leavingVNode = leavingVNodesCache[key]; 9253 if (leavingVNode && 9254 isSameVNodeType(vnode, leavingVNode) && 9255 leavingVNode.el._leaveCb) { 9256 // force early removal (not cancelled) 9257 leavingVNode.el._leaveCb(); 9258 } 9259 callHook(hook, [el]); 9260 }, 9261 enter(el) { 9262 let hook = onEnter; 9263 let afterHook = onAfterEnter; 9264 let cancelHook = onEnterCancelled; 9265 if (!state.isMounted) { 9266 if (appear) { 9267 hook = onAppear || onEnter; 9268 afterHook = onAfterAppear || onAfterEnter; 9269 cancelHook = onAppearCancelled || onEnterCancelled; 9270 } 9271 else { 9272 return; 9273 } 9274 } 9275 let called = false; 9276 const done = (el._enterCb = (cancelled) => { 9277 if (called) 9278 return; 9279 called = true; 9280 if (cancelled) { 9281 callHook(cancelHook, [el]); 9282 } 9283 else { 9284 callHook(afterHook, [el]); 9285 } 9286 if (hooks.delayedLeave) { 9287 hooks.delayedLeave(); 9288 } 9289 el._enterCb = undefined; 9290 }); 9291 if (hook) { 9292 callAsyncHook(hook, [el, done]); 9293 } 9294 else { 9295 done(); 9296 } 9297 }, 9298 leave(el, remove) { 9299 const key = String(vnode.key); 9300 if (el._enterCb) { 9301 el._enterCb(true /* cancelled */); 9302 } 9303 if (state.isUnmounting) { 9304 return remove(); 9305 } 9306 callHook(onBeforeLeave, [el]); 9307 let called = false; 9308 const done = (el._leaveCb = (cancelled) => { 9309 if (called) 9310 return; 9311 called = true; 9312 remove(); 9313 if (cancelled) { 9314 callHook(onLeaveCancelled, [el]); 9315 } 9316 else { 9317 callHook(onAfterLeave, [el]); 9318 } 9319 el._leaveCb = undefined; 9320 if (leavingVNodesCache[key] === vnode) { 9321 delete leavingVNodesCache[key]; 9322 } 9323 }); 9324 leavingVNodesCache[key] = vnode; 9325 if (onLeave) { 9326 callAsyncHook(onLeave, [el, done]); 9327 } 9328 else { 9329 done(); 9330 } 9331 }, 9332 clone(vnode) { 9333 return resolveTransitionHooks(vnode, props, state, instance); 9334 } 9335 }; 9336 return hooks; 9337} 9338// the placeholder really only handles one special case: KeepAlive 9339// in the case of a KeepAlive in a leave phase we need to return a KeepAlive 9340// placeholder with empty content to avoid the KeepAlive instance from being 9341// unmounted. 9342function emptyPlaceholder(vnode) { 9343 if (isKeepAlive(vnode)) { 9344 vnode = cloneVNode(vnode); 9345 vnode.children = null; 9346 return vnode; 9347 } 9348} 9349function getKeepAliveChild(vnode) { 9350 return isKeepAlive(vnode) 9351 ? vnode.children 9352 ? vnode.children[0] 9353 : undefined 9354 : vnode; 9355} 9356function setTransitionHooks(vnode, hooks) { 9357 if (vnode.shapeFlag & 6 /* ShapeFlags.COMPONENT */ && vnode.component) { 9358 setTransitionHooks(vnode.component.subTree, hooks); 9359 } 9360 else if (vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */) { 9361 vnode.ssContent.transition = hooks.clone(vnode.ssContent); 9362 vnode.ssFallback.transition = hooks.clone(vnode.ssFallback); 9363 } 9364 else { 9365 vnode.transition = hooks; 9366 } 9367} 9368function getTransitionRawChildren(children, keepComment = false, parentKey) { 9369 let ret = []; 9370 let keyedFragmentCount = 0; 9371 for (let i = 0; i < children.length; i++) { 9372 let child = children[i]; 9373 // #5360 inherit parent key in case of <template v-for> 9374 const key = parentKey == null 9375 ? child.key 9376 : String(parentKey) + String(child.key != null ? child.key : i); 9377 // handle fragment children case, e.g. v-for 9378 if (child.type === Fragment) { 9379 if (child.patchFlag & 128 /* PatchFlags.KEYED_FRAGMENT */) 9380 keyedFragmentCount++; 9381 ret = ret.concat(getTransitionRawChildren(child.children, keepComment, key)); 9382 } 9383 // comment placeholders should be skipped, e.g. v-if 9384 else if (keepComment || child.type !== Comment) { 9385 ret.push(key != null ? cloneVNode(child, { key }) : child); 9386 } 9387 } 9388 // #1126 if a transition children list contains multiple sub fragments, these 9389 // fragments will be merged into a flat children array. Since each v-for 9390 // fragment may contain different static bindings inside, we need to de-op 9391 // these children to force full diffs to ensure correct behavior. 9392 if (keyedFragmentCount > 1) { 9393 for (let i = 0; i < ret.length; i++) { 9394 ret[i].patchFlag = -2 /* PatchFlags.BAIL */; 9395 } 9396 } 9397 return ret; 9398} 9399 9400// implementation, close to no-op 9401function defineComponent(options) { 9402 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(options) ? { setup: options, name: options.name } : options; 9403} 9404 9405const isAsyncWrapper = (i) => !!i.type.__asyncLoader; 9406function defineAsyncComponent(source) { 9407 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(source)) { 9408 source = { loader: source }; 9409 } 9410 const { loader, loadingComponent, errorComponent, delay = 200, timeout, // undefined = never times out 9411 suspensible = true, onError: userOnError } = source; 9412 let pendingRequest = null; 9413 let resolvedComp; 9414 let retries = 0; 9415 const retry = () => { 9416 retries++; 9417 pendingRequest = null; 9418 return load(); 9419 }; 9420 const load = () => { 9421 let thisRequest; 9422 return (pendingRequest || 9423 (thisRequest = pendingRequest = 9424 loader() 9425 .catch(err => { 9426 err = err instanceof Error ? err : new Error(String(err)); 9427 if (userOnError) { 9428 return new Promise((resolve, reject) => { 9429 const userRetry = () => resolve(retry()); 9430 const userFail = () => reject(err); 9431 userOnError(err, userRetry, userFail, retries + 1); 9432 }); 9433 } 9434 else { 9435 throw err; 9436 } 9437 }) 9438 .then((comp) => { 9439 if (thisRequest !== pendingRequest && pendingRequest) { 9440 return pendingRequest; 9441 } 9442 if (( true) && !comp) { 9443 warn(`Async component loader resolved to undefined. ` + 9444 `If you are using retry(), make sure to return its return value.`); 9445 } 9446 // interop module default 9447 if (comp && 9448 (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) { 9449 comp = comp.default; 9450 } 9451 if (( true) && comp && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(comp)) { 9452 throw new Error(`Invalid async component load result: ${comp}`); 9453 } 9454 resolvedComp = comp; 9455 return comp; 9456 }))); 9457 }; 9458 return defineComponent({ 9459 name: 'AsyncComponentWrapper', 9460 __asyncLoader: load, 9461 get __asyncResolved() { 9462 return resolvedComp; 9463 }, 9464 setup() { 9465 const instance = currentInstance; 9466 // already resolved 9467 if (resolvedComp) { 9468 return () => createInnerComp(resolvedComp, instance); 9469 } 9470 const onError = (err) => { 9471 pendingRequest = null; 9472 handleError(err, instance, 13 /* ErrorCodes.ASYNC_COMPONENT_LOADER */, !errorComponent /* do not throw in dev if user provided error component */); 9473 }; 9474 // suspense-controlled or SSR. 9475 if ((suspensible && instance.suspense) || 9476 (isInSSRComponentSetup)) { 9477 return load() 9478 .then(comp => { 9479 return () => createInnerComp(comp, instance); 9480 }) 9481 .catch(err => { 9482 onError(err); 9483 return () => errorComponent 9484 ? createVNode(errorComponent, { 9485 error: err 9486 }) 9487 : null; 9488 }); 9489 } 9490 const loaded = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)(false); 9491 const error = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)(); 9492 const delayed = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)(!!delay); 9493 if (delay) { 9494 setTimeout(() => { 9495 delayed.value = false; 9496 }, delay); 9497 } 9498 if (timeout != null) { 9499 setTimeout(() => { 9500 if (!loaded.value && !error.value) { 9501 const err = new Error(`Async component timed out after ${timeout}ms.`); 9502 onError(err); 9503 error.value = err; 9504 } 9505 }, timeout); 9506 } 9507 load() 9508 .then(() => { 9509 loaded.value = true; 9510 if (instance.parent && isKeepAlive(instance.parent.vnode)) { 9511 // parent is keep-alive, force update so the loaded component's 9512 // name is taken into account 9513 queueJob(instance.parent.update); 9514 } 9515 }) 9516 .catch(err => { 9517 onError(err); 9518 error.value = err; 9519 }); 9520 return () => { 9521 if (loaded.value && resolvedComp) { 9522 return createInnerComp(resolvedComp, instance); 9523 } 9524 else if (error.value && errorComponent) { 9525 return createVNode(errorComponent, { 9526 error: error.value 9527 }); 9528 } 9529 else if (loadingComponent && !delayed.value) { 9530 return createVNode(loadingComponent); 9531 } 9532 }; 9533 } 9534 }); 9535} 9536function createInnerComp(comp, parent) { 9537 const { ref, props, children, ce } = parent.vnode; 9538 const vnode = createVNode(comp, props, children); 9539 // ensure inner component inherits the async wrapper's ref owner 9540 vnode.ref = ref; 9541 // pass the custom element callback on to the inner comp 9542 // and remove it from the async wrapper 9543 vnode.ce = ce; 9544 delete parent.vnode.ce; 9545 return vnode; 9546} 9547 9548const isKeepAlive = (vnode) => vnode.type.__isKeepAlive; 9549const KeepAliveImpl = { 9550 name: `KeepAlive`, 9551 // Marker for special handling inside the renderer. We are not using a === 9552 // check directly on KeepAlive in the renderer, because importing it directly 9553 // would prevent it from being tree-shaken. 9554 __isKeepAlive: true, 9555 props: { 9556 include: [String, RegExp, Array], 9557 exclude: [String, RegExp, Array], 9558 max: [String, Number] 9559 }, 9560 setup(props, { slots }) { 9561 const instance = getCurrentInstance(); 9562 // KeepAlive communicates with the instantiated renderer via the 9563 // ctx where the renderer passes in its internals, 9564 // and the KeepAlive instance exposes activate/deactivate implementations. 9565 // The whole point of this is to avoid importing KeepAlive directly in the 9566 // renderer to facilitate tree-shaking. 9567 const sharedContext = instance.ctx; 9568 // if the internal renderer is not registered, it indicates that this is server-side rendering, 9569 // for KeepAlive, we just need to render its children 9570 if (!sharedContext.renderer) { 9571 return () => { 9572 const children = slots.default && slots.default(); 9573 return children && children.length === 1 ? children[0] : children; 9574 }; 9575 } 9576 const cache = new Map(); 9577 const keys = new Set(); 9578 let current = null; 9579 if (true) { 9580 instance.__v_cache = cache; 9581 } 9582 const parentSuspense = instance.suspense; 9583 const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext; 9584 const storageContainer = createElement('div'); 9585 sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => { 9586 const instance = vnode.component; 9587 move(vnode, container, anchor, 0 /* MoveType.ENTER */, parentSuspense); 9588 // in case props have changed 9589 patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, vnode.slotScopeIds, optimized); 9590 queuePostRenderEffect(() => { 9591 instance.isDeactivated = false; 9592 if (instance.a) { 9593 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance.a); 9594 } 9595 const vnodeHook = vnode.props && vnode.props.onVnodeMounted; 9596 if (vnodeHook) { 9597 invokeVNodeHook(vnodeHook, instance.parent, vnode); 9598 } 9599 }, parentSuspense); 9600 if (true) { 9601 // Update components tree 9602 devtoolsComponentAdded(instance); 9603 } 9604 }; 9605 sharedContext.deactivate = (vnode) => { 9606 const instance = vnode.component; 9607 move(vnode, storageContainer, null, 1 /* MoveType.LEAVE */, parentSuspense); 9608 queuePostRenderEffect(() => { 9609 if (instance.da) { 9610 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance.da); 9611 } 9612 const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted; 9613 if (vnodeHook) { 9614 invokeVNodeHook(vnodeHook, instance.parent, vnode); 9615 } 9616 instance.isDeactivated = true; 9617 }, parentSuspense); 9618 if (true) { 9619 // Update components tree 9620 devtoolsComponentAdded(instance); 9621 } 9622 }; 9623 function unmount(vnode) { 9624 // reset the shapeFlag so it can be properly unmounted 9625 resetShapeFlag(vnode); 9626 _unmount(vnode, instance, parentSuspense, true); 9627 } 9628 function pruneCache(filter) { 9629 cache.forEach((vnode, key) => { 9630 const name = getComponentName(vnode.type); 9631 if (name && (!filter || !filter(name))) { 9632 pruneCacheEntry(key); 9633 } 9634 }); 9635 } 9636 function pruneCacheEntry(key) { 9637 const cached = cache.get(key); 9638 if (!current || cached.type !== current.type) { 9639 unmount(cached); 9640 } 9641 else if (current) { 9642 // current active instance should no longer be kept-alive. 9643 // we can't unmount it now but it might be later, so reset its flag now. 9644 resetShapeFlag(current); 9645 } 9646 cache.delete(key); 9647 keys.delete(key); 9648 } 9649 // prune cache on include/exclude prop change 9650 watch(() => [props.include, props.exclude], ([include, exclude]) => { 9651 include && pruneCache(name => matches(include, name)); 9652 exclude && pruneCache(name => !matches(exclude, name)); 9653 }, 9654 // prune post-render after `current` has been updated 9655 { flush: 'post', deep: true }); 9656 // cache sub tree after render 9657 let pendingCacheKey = null; 9658 const cacheSubtree = () => { 9659 // fix #1621, the pendingCacheKey could be 0 9660 if (pendingCacheKey != null) { 9661 cache.set(pendingCacheKey, getInnerChild(instance.subTree)); 9662 } 9663 }; 9664 onMounted(cacheSubtree); 9665 onUpdated(cacheSubtree); 9666 onBeforeUnmount(() => { 9667 cache.forEach(cached => { 9668 const { subTree, suspense } = instance; 9669 const vnode = getInnerChild(subTree); 9670 if (cached.type === vnode.type) { 9671 // current instance will be unmounted as part of keep-alive's unmount 9672 resetShapeFlag(vnode); 9673 // but invoke its deactivated hook here 9674 const da = vnode.component.da; 9675 da && queuePostRenderEffect(da, suspense); 9676 return; 9677 } 9678 unmount(cached); 9679 }); 9680 }); 9681 return () => { 9682 pendingCacheKey = null; 9683 if (!slots.default) { 9684 return null; 9685 } 9686 const children = slots.default(); 9687 const rawVNode = children[0]; 9688 if (children.length > 1) { 9689 if ((true)) { 9690 warn(`KeepAlive should contain exactly one component child.`); 9691 } 9692 current = null; 9693 return children; 9694 } 9695 else if (!isVNode(rawVNode) || 9696 (!(rawVNode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */) && 9697 !(rawVNode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */))) { 9698 current = null; 9699 return rawVNode; 9700 } 9701 let vnode = getInnerChild(rawVNode); 9702 const comp = vnode.type; 9703 // for async components, name check should be based in its loaded 9704 // inner component if available 9705 const name = getComponentName(isAsyncWrapper(vnode) 9706 ? vnode.type.__asyncResolved || {} 9707 : comp); 9708 const { include, exclude, max } = props; 9709 if ((include && (!name || !matches(include, name))) || 9710 (exclude && name && matches(exclude, name))) { 9711 current = vnode; 9712 return rawVNode; 9713 } 9714 const key = vnode.key == null ? comp : vnode.key; 9715 const cachedVNode = cache.get(key); 9716 // clone vnode if it's reused because we are going to mutate it 9717 if (vnode.el) { 9718 vnode = cloneVNode(vnode); 9719 if (rawVNode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */) { 9720 rawVNode.ssContent = vnode; 9721 } 9722 } 9723 // #1513 it's possible for the returned vnode to be cloned due to attr 9724 // fallthrough or scopeId, so the vnode here may not be the final vnode 9725 // that is mounted. Instead of caching it directly, we store the pending 9726 // key and cache `instance.subTree` (the normalized vnode) in 9727 // beforeMount/beforeUpdate hooks. 9728 pendingCacheKey = key; 9729 if (cachedVNode) { 9730 // copy over mounted state 9731 vnode.el = cachedVNode.el; 9732 vnode.component = cachedVNode.component; 9733 if (vnode.transition) { 9734 // recursively update transition hooks on subTree 9735 setTransitionHooks(vnode, vnode.transition); 9736 } 9737 // avoid vnode being mounted as fresh 9738 vnode.shapeFlag |= 512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */; 9739 // make this key the freshest 9740 keys.delete(key); 9741 keys.add(key); 9742 } 9743 else { 9744 keys.add(key); 9745 // prune oldest entry 9746 if (max && keys.size > parseInt(max, 10)) { 9747 pruneCacheEntry(keys.values().next().value); 9748 } 9749 } 9750 // avoid vnode being unmounted 9751 vnode.shapeFlag |= 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */; 9752 current = vnode; 9753 return isSuspense(rawVNode.type) ? rawVNode : vnode; 9754 }; 9755 } 9756}; 9757// export the public type for h/tsx inference 9758// also to avoid inline import() in generated d.ts files 9759const KeepAlive = KeepAliveImpl; 9760function matches(pattern, name) { 9761 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(pattern)) { 9762 return pattern.some((p) => matches(p, name)); 9763 } 9764 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(pattern)) { 9765 return pattern.split(',').includes(name); 9766 } 9767 else if (pattern.test) { 9768 return pattern.test(name); 9769 } 9770 /* istanbul ignore next */ 9771 return false; 9772} 9773function onActivated(hook, target) { 9774 registerKeepAliveHook(hook, "a" /* LifecycleHooks.ACTIVATED */, target); 9775} 9776function onDeactivated(hook, target) { 9777 registerKeepAliveHook(hook, "da" /* LifecycleHooks.DEACTIVATED */, target); 9778} 9779function registerKeepAliveHook(hook, type, target = currentInstance) { 9780 // cache the deactivate branch check wrapper for injected hooks so the same 9781 // hook can be properly deduped by the scheduler. "__wdc" stands for "with 9782 // deactivation check". 9783 const wrappedHook = hook.__wdc || 9784 (hook.__wdc = () => { 9785 // only fire the hook if the target instance is NOT in a deactivated branch. 9786 let current = target; 9787 while (current) { 9788 if (current.isDeactivated) { 9789 return; 9790 } 9791 current = current.parent; 9792 } 9793 return hook(); 9794 }); 9795 injectHook(type, wrappedHook, target); 9796 // In addition to registering it on the target instance, we walk up the parent 9797 // chain and register it on all ancestor instances that are keep-alive roots. 9798 // This avoids the need to walk the entire component tree when invoking these 9799 // hooks, and more importantly, avoids the need to track child components in 9800 // arrays. 9801 if (target) { 9802 let current = target.parent; 9803 while (current && current.parent) { 9804 if (isKeepAlive(current.parent.vnode)) { 9805 injectToKeepAliveRoot(wrappedHook, type, target, current); 9806 } 9807 current = current.parent; 9808 } 9809 } 9810} 9811function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { 9812 // injectHook wraps the original for error handling, so make sure to remove 9813 // the wrapped version. 9814 const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */); 9815 onUnmounted(() => { 9816 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.remove)(keepAliveRoot[type], injected); 9817 }, target); 9818} 9819function resetShapeFlag(vnode) { 9820 // bitwise operations to remove keep alive flags 9821 vnode.shapeFlag &= ~256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */; 9822 vnode.shapeFlag &= ~512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */; 9823} 9824function getInnerChild(vnode) { 9825 return vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */ ? vnode.ssContent : vnode; 9826} 9827 9828function injectHook(type, hook, target = currentInstance, prepend = false) { 9829 if (target) { 9830 const hooks = target[type] || (target[type] = []); 9831 // cache the error handling wrapper for injected hooks so the same hook 9832 // can be properly deduped by the scheduler. "__weh" stands for "with error 9833 // handling". 9834 const wrappedHook = hook.__weh || 9835 (hook.__weh = (...args) => { 9836 if (target.isUnmounted) { 9837 return; 9838 } 9839 // disable tracking inside all lifecycle hooks 9840 // since they can potentially be called inside effects. 9841 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 9842 // Set currentInstance during hook invocation. 9843 // This assumes the hook does not synchronously trigger other hooks, which 9844 // can only be false when the user does something really funky. 9845 setCurrentInstance(target); 9846 const res = callWithAsyncErrorHandling(hook, target, type, args); 9847 unsetCurrentInstance(); 9848 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 9849 return res; 9850 }); 9851 if (prepend) { 9852 hooks.unshift(wrappedHook); 9853 } 9854 else { 9855 hooks.push(wrappedHook); 9856 } 9857 return wrappedHook; 9858 } 9859 else if ((true)) { 9860 const apiName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(ErrorTypeStrings[type].replace(/ hook$/, '')); 9861 warn(`${apiName} is called when there is no active component instance to be ` + 9862 `associated with. ` + 9863 `Lifecycle injection APIs can only be used during execution of setup().` + 9864 (` If you are using async setup(), make sure to register lifecycle ` + 9865 `hooks before the first await statement.` 9866 )); 9867 } 9868} 9869const createHook = (lifecycle) => (hook, target = currentInstance) => 9870// post-create lifecycle registrations are noops during SSR (except for serverPrefetch) 9871(!isInSSRComponentSetup || lifecycle === "sp" /* LifecycleHooks.SERVER_PREFETCH */) && 9872 injectHook(lifecycle, (...args) => hook(...args), target); 9873const onBeforeMount = createHook("bm" /* LifecycleHooks.BEFORE_MOUNT */); 9874const onMounted = createHook("m" /* LifecycleHooks.MOUNTED */); 9875const onBeforeUpdate = createHook("bu" /* LifecycleHooks.BEFORE_UPDATE */); 9876const onUpdated = createHook("u" /* LifecycleHooks.UPDATED */); 9877const onBeforeUnmount = createHook("bum" /* LifecycleHooks.BEFORE_UNMOUNT */); 9878const onUnmounted = createHook("um" /* LifecycleHooks.UNMOUNTED */); 9879const onServerPrefetch = createHook("sp" /* LifecycleHooks.SERVER_PREFETCH */); 9880const onRenderTriggered = createHook("rtg" /* LifecycleHooks.RENDER_TRIGGERED */); 9881const onRenderTracked = createHook("rtc" /* LifecycleHooks.RENDER_TRACKED */); 9882function onErrorCaptured(hook, target = currentInstance) { 9883 injectHook("ec" /* LifecycleHooks.ERROR_CAPTURED */, hook, target); 9884} 9885 9886/** 9887Runtime helper for applying directives to a vnode. Example usage: 9888 9889const comp = resolveComponent('comp') 9890const foo = resolveDirective('foo') 9891const bar = resolveDirective('bar') 9892 9893return withDirectives(h(comp), [ 9894 [foo, this.x], 9895 [bar, this.y] 9896]) 9897*/ 9898function validateDirectiveName(name) { 9899 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isBuiltInDirective)(name)) { 9900 warn('Do not use built-in directive ids as custom directive id: ' + name); 9901 } 9902} 9903/** 9904 * Adds directives to a VNode. 9905 */ 9906function withDirectives(vnode, directives) { 9907 const internalInstance = currentRenderingInstance; 9908 if (internalInstance === null) { 9909 ( true) && warn(`withDirectives can only be used inside render functions.`); 9910 return vnode; 9911 } 9912 const instance = getExposeProxy(internalInstance) || 9913 internalInstance.proxy; 9914 const bindings = vnode.dirs || (vnode.dirs = []); 9915 for (let i = 0; i < directives.length; i++) { 9916 let [dir, value, arg, modifiers = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ] = directives[i]; 9917 if (dir) { 9918 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(dir)) { 9919 dir = { 9920 mounted: dir, 9921 updated: dir 9922 }; 9923 } 9924 if (dir.deep) { 9925 traverse(value); 9926 } 9927 bindings.push({ 9928 dir, 9929 instance, 9930 value, 9931 oldValue: void 0, 9932 arg, 9933 modifiers 9934 }); 9935 } 9936 } 9937 return vnode; 9938} 9939function invokeDirectiveHook(vnode, prevVNode, instance, name) { 9940 const bindings = vnode.dirs; 9941 const oldBindings = prevVNode && prevVNode.dirs; 9942 for (let i = 0; i < bindings.length; i++) { 9943 const binding = bindings[i]; 9944 if (oldBindings) { 9945 binding.oldValue = oldBindings[i].value; 9946 } 9947 let hook = binding.dir[name]; 9948 if (hook) { 9949 // disable tracking inside all lifecycle hooks 9950 // since they can potentially be called inside effects. 9951 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 9952 callWithAsyncErrorHandling(hook, instance, 8 /* ErrorCodes.DIRECTIVE_HOOK */, [ 9953 vnode.el, 9954 binding, 9955 vnode, 9956 prevVNode 9957 ]); 9958 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 9959 } 9960 } 9961} 9962 9963const COMPONENTS = 'components'; 9964const DIRECTIVES = 'directives'; 9965/** 9966 * @private 9967 */ 9968function resolveComponent(name, maybeSelfReference) { 9969 return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name; 9970} 9971const NULL_DYNAMIC_COMPONENT = Symbol(); 9972/** 9973 * @private 9974 */ 9975function resolveDynamicComponent(component) { 9976 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(component)) { 9977 return resolveAsset(COMPONENTS, component, false) || component; 9978 } 9979 else { 9980 // invalid types will fallthrough to createVNode and raise warning 9981 return (component || NULL_DYNAMIC_COMPONENT); 9982 } 9983} 9984/** 9985 * @private 9986 */ 9987function resolveDirective(name) { 9988 return resolveAsset(DIRECTIVES, name); 9989} 9990// implementation 9991function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) { 9992 const instance = currentRenderingInstance || currentInstance; 9993 if (instance) { 9994 const Component = instance.type; 9995 // explicit self name has highest priority 9996 if (type === COMPONENTS) { 9997 const selfName = getComponentName(Component, false /* do not include inferred name to avoid breaking existing code */); 9998 if (selfName && 9999 (selfName === name || 10000 selfName === (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name) || 10001 selfName === (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name)))) { 10002 return Component; 10003 } 10004 } 10005 const res = 10006 // local registration 10007 // check instance[type] first which is resolved for options API 10008 resolve(instance[type] || Component[type], name) || 10009 // global registration 10010 resolve(instance.appContext[type], name); 10011 if (!res && maybeSelfReference) { 10012 // fallback to implicit self-reference 10013 return Component; 10014 } 10015 if (( true) && warnMissing && !res) { 10016 const extra = type === COMPONENTS 10017 ? `\nIf this is a native custom element, make sure to exclude it from ` + 10018 `component resolution via compilerOptions.isCustomElement.` 10019 : ``; 10020 warn(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`); 10021 } 10022 return res; 10023 } 10024 else if ((true)) { 10025 warn(`resolve${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)(type.slice(0, -1))} ` + 10026 `can only be used in render() or setup().`); 10027 } 10028} 10029function resolve(registry, name) { 10030 return (registry && 10031 (registry[name] || 10032 registry[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name)] || 10033 registry[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name))])); 10034} 10035 10036/** 10037 * Actual implementation 10038 */ 10039function renderList(source, renderItem, cache, index) { 10040 let ret; 10041 const cached = (cache && cache[index]); 10042 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(source) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(source)) { 10043 ret = new Array(source.length); 10044 for (let i = 0, l = source.length; i < l; i++) { 10045 ret[i] = renderItem(source[i], i, undefined, cached && cached[i]); 10046 } 10047 } 10048 else if (typeof source === 'number') { 10049 if (( true) && !Number.isInteger(source)) { 10050 warn(`The v-for range expect an integer value but got ${source}.`); 10051 } 10052 ret = new Array(source); 10053 for (let i = 0; i < source; i++) { 10054 ret[i] = renderItem(i + 1, i, undefined, cached && cached[i]); 10055 } 10056 } 10057 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(source)) { 10058 if (source[Symbol.iterator]) { 10059 ret = Array.from(source, (item, i) => renderItem(item, i, undefined, cached && cached[i])); 10060 } 10061 else { 10062 const keys = Object.keys(source); 10063 ret = new Array(keys.length); 10064 for (let i = 0, l = keys.length; i < l; i++) { 10065 const key = keys[i]; 10066 ret[i] = renderItem(source[key], key, i, cached && cached[i]); 10067 } 10068 } 10069 } 10070 else { 10071 ret = []; 10072 } 10073 if (cache) { 10074 cache[index] = ret; 10075 } 10076 return ret; 10077} 10078 10079/** 10080 * Compiler runtime helper for creating dynamic slots object 10081 * @private 10082 */ 10083function createSlots(slots, dynamicSlots) { 10084 for (let i = 0; i < dynamicSlots.length; i++) { 10085 const slot = dynamicSlots[i]; 10086 // array of dynamic slot generated by <template v-for="..." #[...]> 10087 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(slot)) { 10088 for (let j = 0; j < slot.length; j++) { 10089 slots[slot[j].name] = slot[j].fn; 10090 } 10091 } 10092 else if (slot) { 10093 // conditional single slot generated by <template v-if="..." #foo> 10094 slots[slot.name] = slot.key 10095 ? (...args) => { 10096 const res = slot.fn(...args); 10097 // attach branch key so each conditional branch is considered a 10098 // different fragment 10099 if (res) 10100 res.key = slot.key; 10101 return res; 10102 } 10103 : slot.fn; 10104 } 10105 } 10106 return slots; 10107} 10108 10109/** 10110 * Compiler runtime helper for rendering `<slot/>` 10111 * @private 10112 */ 10113function renderSlot(slots, name, props = {}, 10114// this is not a user-facing function, so the fallback is always generated by 10115// the compiler and guaranteed to be a function returning an array 10116fallback, noSlotted) { 10117 if (currentRenderingInstance.isCE || 10118 (currentRenderingInstance.parent && 10119 isAsyncWrapper(currentRenderingInstance.parent) && 10120 currentRenderingInstance.parent.isCE)) { 10121 if (name !== 'default') 10122 props.name = name; 10123 return createVNode('slot', props, fallback && fallback()); 10124 } 10125 let slot = slots[name]; 10126 if (( true) && slot && slot.length > 1) { 10127 warn(`SSR-optimized slot function detected in a non-SSR-optimized render ` + 10128 `function. You need to mark this component with $dynamic-slots in the ` + 10129 `parent template.`); 10130 slot = () => []; 10131 } 10132 // a compiled slot disables block tracking by default to avoid manual 10133 // invocation interfering with template-based block tracking, but in 10134 // `renderSlot` we can be sure that it's template-based so we can force 10135 // enable it. 10136 if (slot && slot._c) { 10137 slot._d = false; 10138 } 10139 openBlock(); 10140 const validSlotContent = slot && ensureValidVNode(slot(props)); 10141 const rendered = createBlock(Fragment, { 10142 key: props.key || 10143 // slot content array of a dynamic conditional slot may have a branch 10144 // key attached in the `createSlots` helper, respect that 10145 (validSlotContent && validSlotContent.key) || 10146 `_${name}` 10147 }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 /* SlotFlags.STABLE */ 10148 ? 64 /* PatchFlags.STABLE_FRAGMENT */ 10149 : -2 /* PatchFlags.BAIL */); 10150 if (!noSlotted && rendered.scopeId) { 10151 rendered.slotScopeIds = [rendered.scopeId + '-s']; 10152 } 10153 if (slot && slot._c) { 10154 slot._d = true; 10155 } 10156 return rendered; 10157} 10158function ensureValidVNode(vnodes) { 10159 return vnodes.some(child => { 10160 if (!isVNode(child)) 10161 return true; 10162 if (child.type === Comment) 10163 return false; 10164 if (child.type === Fragment && 10165 !ensureValidVNode(child.children)) 10166 return false; 10167 return true; 10168 }) 10169 ? vnodes 10170 : null; 10171} 10172 10173/** 10174 * For prefixing keys in v-on="obj" with "on" 10175 * @private 10176 */ 10177function toHandlers(obj, preserveCaseIfNecessary) { 10178 const ret = {}; 10179 if (( true) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(obj)) { 10180 warn(`v-on with no argument expects an object value.`); 10181 return ret; 10182 } 10183 for (const key in obj) { 10184 ret[preserveCaseIfNecessary && /[A-Z]/.test(key) 10185 ? `on:${key}` 10186 : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(key)] = obj[key]; 10187 } 10188 return ret; 10189} 10190 10191/** 10192 * #2437 In Vue 3, functional components do not have a public instance proxy but 10193 * they exist in the internal parent chain. For code that relies on traversing 10194 * public $parent chains, skip functional ones and go to the parent instead. 10195 */ 10196const getPublicInstance = (i) => { 10197 if (!i) 10198 return null; 10199 if (isStatefulComponent(i)) 10200 return getExposeProxy(i) || i.proxy; 10201 return getPublicInstance(i.parent); 10202}; 10203const publicPropertiesMap = 10204// Move PURE marker to new line to workaround compiler discarding it 10205// due to type annotation 10206/*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(Object.create(null), { 10207 $: i => i, 10208 $el: i => i.vnode.el, 10209 $data: i => i.data, 10210 $props: i => (( true) ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.props) : 0), 10211 $attrs: i => (( true) ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.attrs) : 0), 10212 $slots: i => (( true) ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.slots) : 0), 10213 $refs: i => (( true) ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.refs) : 0), 10214 $parent: i => getPublicInstance(i.parent), 10215 $root: i => getPublicInstance(i.root), 10216 $emit: i => i.emit, 10217 $options: i => ( true ? resolveMergedOptions(i) : 0), 10218 $forceUpdate: i => i.f || (i.f = () => queueJob(i.update)), 10219 $nextTick: i => i.n || (i.n = nextTick.bind(i.proxy)), 10220 $watch: i => ( true ? instanceWatch.bind(i) : 0) 10221}); 10222const isReservedPrefix = (key) => key === '_' || key === '$'; 10223const hasSetupBinding = (state, key) => state !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && !state.__isScriptSetup && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(state, key); 10224const PublicInstanceProxyHandlers = { 10225 get({ _: instance }, key) { 10226 const { ctx, setupState, data, props, accessCache, type, appContext } = instance; 10227 // for internal formatters to know that this is a Vue instance 10228 if (( true) && key === '__isVue') { 10229 return true; 10230 } 10231 // data / props / ctx 10232 // This getter gets called for every property access on the render context 10233 // during render and is a major hotspot. The most expensive part of this 10234 // is the multiple hasOwn() calls. It's much faster to do a simple property 10235 // access on a plain object, so we use an accessCache object (with null 10236 // prototype) to memoize what access type a key corresponds to. 10237 let normalizedProps; 10238 if (key[0] !== '$') { 10239 const n = accessCache[key]; 10240 if (n !== undefined) { 10241 switch (n) { 10242 case 1 /* AccessTypes.SETUP */: 10243 return setupState[key]; 10244 case 2 /* AccessTypes.DATA */: 10245 return data[key]; 10246 case 4 /* AccessTypes.CONTEXT */: 10247 return ctx[key]; 10248 case 3 /* AccessTypes.PROPS */: 10249 return props[key]; 10250 // default: just fallthrough 10251 } 10252 } 10253 else if (hasSetupBinding(setupState, key)) { 10254 accessCache[key] = 1 /* AccessTypes.SETUP */; 10255 return setupState[key]; 10256 } 10257 else if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key)) { 10258 accessCache[key] = 2 /* AccessTypes.DATA */; 10259 return data[key]; 10260 } 10261 else if ( 10262 // only cache other properties when instance has declared (thus stable) 10263 // props 10264 (normalizedProps = instance.propsOptions[0]) && 10265 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(normalizedProps, key)) { 10266 accessCache[key] = 3 /* AccessTypes.PROPS */; 10267 return props[key]; 10268 } 10269 else if (ctx !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(ctx, key)) { 10270 accessCache[key] = 4 /* AccessTypes.CONTEXT */; 10271 return ctx[key]; 10272 } 10273 else if ( false || shouldCacheAccess) { 10274 accessCache[key] = 0 /* AccessTypes.OTHER */; 10275 } 10276 } 10277 const publicGetter = publicPropertiesMap[key]; 10278 let cssModule, globalProperties; 10279 // public $xxx properties 10280 if (publicGetter) { 10281 if (key === '$attrs') { 10282 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.track)(instance, "get" /* TrackOpTypes.GET */, key); 10283 ( true) && markAttrsAccessed(); 10284 } 10285 return publicGetter(instance); 10286 } 10287 else if ( 10288 // css module (injected by vue-loader) 10289 (cssModule = type.__cssModules) && 10290 (cssModule = cssModule[key])) { 10291 return cssModule; 10292 } 10293 else if (ctx !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(ctx, key)) { 10294 // user may set custom properties to `this` that start with `$` 10295 accessCache[key] = 4 /* AccessTypes.CONTEXT */; 10296 return ctx[key]; 10297 } 10298 else if ( 10299 // global properties 10300 ((globalProperties = appContext.config.globalProperties), 10301 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(globalProperties, key))) { 10302 { 10303 return globalProperties[key]; 10304 } 10305 } 10306 else if (( true) && 10307 currentRenderingInstance && 10308 (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(key) || 10309 // #1091 avoid internal isRef/isVNode checks on component instance leading 10310 // to infinite warning loop 10311 key.indexOf('__v') !== 0)) { 10312 if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && isReservedPrefix(key[0]) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key)) { 10313 warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` + 10314 `character ("$" or "_") and is not proxied on the render context.`); 10315 } 10316 else if (instance === currentRenderingInstance) { 10317 warn(`Property ${JSON.stringify(key)} was accessed during render ` + 10318 `but is not defined on instance.`); 10319 } 10320 } 10321 }, 10322 set({ _: instance }, key, value) { 10323 const { data, setupState, ctx } = instance; 10324 if (hasSetupBinding(setupState, key)) { 10325 setupState[key] = value; 10326 return true; 10327 } 10328 else if (( true) && 10329 setupState.__isScriptSetup && 10330 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, key)) { 10331 warn(`Cannot mutate <script setup> binding "${key}" from Options API.`); 10332 return false; 10333 } 10334 else if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key)) { 10335 data[key] = value; 10336 return true; 10337 } 10338 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(instance.props, key)) { 10339 ( true) && warn(`Attempting to mutate prop "${key}". Props are readonly.`); 10340 return false; 10341 } 10342 if (key[0] === '$' && key.slice(1) in instance) { 10343 ( true) && 10344 warn(`Attempting to mutate public property "${key}". ` + 10345 `Properties starting with $ are reserved and readonly.`); 10346 return false; 10347 } 10348 else { 10349 if (( true) && key in instance.appContext.config.globalProperties) { 10350 Object.defineProperty(ctx, key, { 10351 enumerable: true, 10352 configurable: true, 10353 value 10354 }); 10355 } 10356 else { 10357 ctx[key] = value; 10358 } 10359 } 10360 return true; 10361 }, 10362 has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) { 10363 let normalizedProps; 10364 return (!!accessCache[key] || 10365 (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key)) || 10366 hasSetupBinding(setupState, key) || 10367 ((normalizedProps = propsOptions[0]) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(normalizedProps, key)) || 10368 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(ctx, key) || 10369 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(publicPropertiesMap, key) || 10370 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(appContext.config.globalProperties, key)); 10371 }, 10372 defineProperty(target, key, descriptor) { 10373 if (descriptor.get != null) { 10374 // invalidate key cache of a getter based property #5417 10375 target._.accessCache[key] = 0; 10376 } 10377 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(descriptor, 'value')) { 10378 this.set(target, key, descriptor.value, null); 10379 } 10380 return Reflect.defineProperty(target, key, descriptor); 10381 } 10382}; 10383if (true) { 10384 PublicInstanceProxyHandlers.ownKeys = (target) => { 10385 warn(`Avoid app logic that relies on enumerating keys on a component instance. ` + 10386 `The keys will be empty in production mode to avoid performance overhead.`); 10387 return Reflect.ownKeys(target); 10388 }; 10389} 10390const RuntimeCompiledPublicInstanceProxyHandlers = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, PublicInstanceProxyHandlers, { 10391 get(target, key) { 10392 // fast path for unscopables when using `with` block 10393 if (key === Symbol.unscopables) { 10394 return; 10395 } 10396 return PublicInstanceProxyHandlers.get(target, key, target); 10397 }, 10398 has(_, key) { 10399 const has = key[0] !== '_' && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isGloballyWhitelisted)(key); 10400 if (( true) && !has && PublicInstanceProxyHandlers.has(_, key)) { 10401 warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`); 10402 } 10403 return has; 10404 } 10405}); 10406// dev only 10407// In dev mode, the proxy target exposes the same properties as seen on `this` 10408// for easier console inspection. In prod mode it will be an empty object so 10409// these properties definitions can be skipped. 10410function createDevRenderContext(instance) { 10411 const target = {}; 10412 // expose internal instance for proxy handlers 10413 Object.defineProperty(target, `_`, { 10414 configurable: true, 10415 enumerable: false, 10416 get: () => instance 10417 }); 10418 // expose public properties 10419 Object.keys(publicPropertiesMap).forEach(key => { 10420 Object.defineProperty(target, key, { 10421 configurable: true, 10422 enumerable: false, 10423 get: () => publicPropertiesMap[key](instance), 10424 // intercepted by the proxy so no need for implementation, 10425 // but needed to prevent set errors 10426 set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP 10427 }); 10428 }); 10429 return target; 10430} 10431// dev only 10432function exposePropsOnRenderContext(instance) { 10433 const { ctx, propsOptions: [propsOptions] } = instance; 10434 if (propsOptions) { 10435 Object.keys(propsOptions).forEach(key => { 10436 Object.defineProperty(ctx, key, { 10437 enumerable: true, 10438 configurable: true, 10439 get: () => instance.props[key], 10440 set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP 10441 }); 10442 }); 10443 } 10444} 10445// dev only 10446function exposeSetupStateOnRenderContext(instance) { 10447 const { ctx, setupState } = instance; 10448 Object.keys((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(setupState)).forEach(key => { 10449 if (!setupState.__isScriptSetup) { 10450 if (isReservedPrefix(key[0])) { 10451 warn(`setup() return property ${JSON.stringify(key)} should not start with "$" or "_" ` + 10452 `which are reserved prefixes for Vue internals.`); 10453 return; 10454 } 10455 Object.defineProperty(ctx, key, { 10456 enumerable: true, 10457 configurable: true, 10458 get: () => setupState[key], 10459 set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP 10460 }); 10461 } 10462 }); 10463} 10464 10465function createDuplicateChecker() { 10466 const cache = Object.create(null); 10467 return (type, key) => { 10468 if (cache[key]) { 10469 warn(`${type} property "${key}" is already defined in ${cache[key]}.`); 10470 } 10471 else { 10472 cache[key] = type; 10473 } 10474 }; 10475} 10476let shouldCacheAccess = true; 10477function applyOptions(instance) { 10478 const options = resolveMergedOptions(instance); 10479 const publicThis = instance.proxy; 10480 const ctx = instance.ctx; 10481 // do not cache property access on public proxy during state initialization 10482 shouldCacheAccess = false; 10483 // call beforeCreate first before accessing other options since 10484 // the hook may mutate resolved options (#2791) 10485 if (options.beforeCreate) { 10486 callHook(options.beforeCreate, instance, "bc" /* LifecycleHooks.BEFORE_CREATE */); 10487 } 10488 const { 10489 // state 10490 data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, 10491 // lifecycle 10492 created, beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeDestroy, beforeUnmount, destroyed, unmounted, render, renderTracked, renderTriggered, errorCaptured, serverPrefetch, 10493 // public API 10494 expose, inheritAttrs, 10495 // assets 10496 components, directives, filters } = options; 10497 const checkDuplicateProperties = ( true) ? createDuplicateChecker() : 0; 10498 if ((true)) { 10499 const [propsOptions] = instance.propsOptions; 10500 if (propsOptions) { 10501 for (const key in propsOptions) { 10502 checkDuplicateProperties("Props" /* OptionTypes.PROPS */, key); 10503 } 10504 } 10505 } 10506 // options initialization order (to be consistent with Vue 2): 10507 // - props (already done outside of this function) 10508 // - inject 10509 // - methods 10510 // - data (deferred since it relies on `this` access) 10511 // - computed 10512 // - watch (deferred since it relies on `this` access) 10513 if (injectOptions) { 10514 resolveInjections(injectOptions, ctx, checkDuplicateProperties, instance.appContext.config.unwrapInjectedRef); 10515 } 10516 if (methods) { 10517 for (const key in methods) { 10518 const methodHandler = methods[key]; 10519 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(methodHandler)) { 10520 // In dev mode, we use the `createRenderContext` function to define 10521 // methods to the proxy target, and those are read-only but 10522 // reconfigurable, so it needs to be redefined here 10523 if ((true)) { 10524 Object.defineProperty(ctx, key, { 10525 value: methodHandler.bind(publicThis), 10526 configurable: true, 10527 enumerable: true, 10528 writable: true 10529 }); 10530 } 10531 else {} 10532 if ((true)) { 10533 checkDuplicateProperties("Methods" /* OptionTypes.METHODS */, key); 10534 } 10535 } 10536 else if ((true)) { 10537 warn(`Method "${key}" has type "${typeof methodHandler}" in the component definition. ` + 10538 `Did you reference the function correctly?`); 10539 } 10540 } 10541 } 10542 if (dataOptions) { 10543 if (( true) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(dataOptions)) { 10544 warn(`The data option must be a function. ` + 10545 `Plain object usage is no longer supported.`); 10546 } 10547 const data = dataOptions.call(publicThis, publicThis); 10548 if (( true) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(data)) { 10549 warn(`data() returned a Promise - note data() cannot be async; If you ` + 10550 `intend to perform data fetching before component renders, use ` + 10551 `async setup() + <Suspense>.`); 10552 } 10553 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(data)) { 10554 ( true) && warn(`data() should return an object.`); 10555 } 10556 else { 10557 instance.data = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.reactive)(data); 10558 if ((true)) { 10559 for (const key in data) { 10560 checkDuplicateProperties("Data" /* OptionTypes.DATA */, key); 10561 // expose data on ctx during dev 10562 if (!isReservedPrefix(key[0])) { 10563 Object.defineProperty(ctx, key, { 10564 configurable: true, 10565 enumerable: true, 10566 get: () => data[key], 10567 set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP 10568 }); 10569 } 10570 } 10571 } 10572 } 10573 } 10574 // state initialization complete at this point - start caching access 10575 shouldCacheAccess = true; 10576 if (computedOptions) { 10577 for (const key in computedOptions) { 10578 const opt = computedOptions[key]; 10579 const get = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt) 10580 ? opt.bind(publicThis, publicThis) 10581 : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt.get) 10582 ? opt.get.bind(publicThis, publicThis) 10583 : _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP; 10584 if (( true) && get === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP) { 10585 warn(`Computed property "${key}" has no getter.`); 10586 } 10587 const set = !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt.set) 10588 ? opt.set.bind(publicThis) 10589 : ( true) 10590 ? () => { 10591 warn(`Write operation failed: computed property "${key}" is readonly.`); 10592 } 10593 : 0; 10594 const c = computed({ 10595 get, 10596 set 10597 }); 10598 Object.defineProperty(ctx, key, { 10599 enumerable: true, 10600 configurable: true, 10601 get: () => c.value, 10602 set: v => (c.value = v) 10603 }); 10604 if ((true)) { 10605 checkDuplicateProperties("Computed" /* OptionTypes.COMPUTED */, key); 10606 } 10607 } 10608 } 10609 if (watchOptions) { 10610 for (const key in watchOptions) { 10611 createWatcher(watchOptions[key], ctx, publicThis, key); 10612 } 10613 } 10614 if (provideOptions) { 10615 const provides = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(provideOptions) 10616 ? provideOptions.call(publicThis) 10617 : provideOptions; 10618 Reflect.ownKeys(provides).forEach(key => { 10619 provide(key, provides[key]); 10620 }); 10621 } 10622 if (created) { 10623 callHook(created, instance, "c" /* LifecycleHooks.CREATED */); 10624 } 10625 function registerLifecycleHook(register, hook) { 10626 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook)) { 10627 hook.forEach(_hook => register(_hook.bind(publicThis))); 10628 } 10629 else if (hook) { 10630 register(hook.bind(publicThis)); 10631 } 10632 } 10633 registerLifecycleHook(onBeforeMount, beforeMount); 10634 registerLifecycleHook(onMounted, mounted); 10635 registerLifecycleHook(onBeforeUpdate, beforeUpdate); 10636 registerLifecycleHook(onUpdated, updated); 10637 registerLifecycleHook(onActivated, activated); 10638 registerLifecycleHook(onDeactivated, deactivated); 10639 registerLifecycleHook(onErrorCaptured, errorCaptured); 10640 registerLifecycleHook(onRenderTracked, renderTracked); 10641 registerLifecycleHook(onRenderTriggered, renderTriggered); 10642 registerLifecycleHook(onBeforeUnmount, beforeUnmount); 10643 registerLifecycleHook(onUnmounted, unmounted); 10644 registerLifecycleHook(onServerPrefetch, serverPrefetch); 10645 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(expose)) { 10646 if (expose.length) { 10647 const exposed = instance.exposed || (instance.exposed = {}); 10648 expose.forEach(key => { 10649 Object.defineProperty(exposed, key, { 10650 get: () => publicThis[key], 10651 set: val => (publicThis[key] = val) 10652 }); 10653 }); 10654 } 10655 else if (!instance.exposed) { 10656 instance.exposed = {}; 10657 } 10658 } 10659 // options that are handled when creating the instance but also need to be 10660 // applied from mixins 10661 if (render && instance.render === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP) { 10662 instance.render = render; 10663 } 10664 if (inheritAttrs != null) { 10665 instance.inheritAttrs = inheritAttrs; 10666 } 10667 // asset options. 10668 if (components) 10669 instance.components = components; 10670 if (directives) 10671 instance.directives = directives; 10672} 10673function resolveInjections(injectOptions, ctx, checkDuplicateProperties = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP, unwrapRef = false) { 10674 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(injectOptions)) { 10675 injectOptions = normalizeInject(injectOptions); 10676 } 10677 for (const key in injectOptions) { 10678 const opt = injectOptions[key]; 10679 let injected; 10680 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(opt)) { 10681 if ('default' in opt) { 10682 injected = inject(opt.from || key, opt.default, true /* treat default function as factory */); 10683 } 10684 else { 10685 injected = inject(opt.from || key); 10686 } 10687 } 10688 else { 10689 injected = inject(opt); 10690 } 10691 if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(injected)) { 10692 // TODO remove the check in 3.3 10693 if (unwrapRef) { 10694 Object.defineProperty(ctx, key, { 10695 enumerable: true, 10696 configurable: true, 10697 get: () => injected.value, 10698 set: v => (injected.value = v) 10699 }); 10700 } 10701 else { 10702 if ((true)) { 10703 warn(`injected property "${key}" is a ref and will be auto-unwrapped ` + 10704 `and no longer needs \`.value\` in the next minor release. ` + 10705 `To opt-in to the new behavior now, ` + 10706 `set \`app.config.unwrapInjectedRef = true\` (this config is ` + 10707 `temporary and will not be needed in the future.)`); 10708 } 10709 ctx[key] = injected; 10710 } 10711 } 10712 else { 10713 ctx[key] = injected; 10714 } 10715 if ((true)) { 10716 checkDuplicateProperties("Inject" /* OptionTypes.INJECT */, key); 10717 } 10718 } 10719} 10720function callHook(hook, instance, type) { 10721 callWithAsyncErrorHandling((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook) 10722 ? hook.map(h => h.bind(instance.proxy)) 10723 : hook.bind(instance.proxy), instance, type); 10724} 10725function createWatcher(raw, ctx, publicThis, key) { 10726 const getter = key.includes('.') 10727 ? createPathGetter(publicThis, key) 10728 : () => publicThis[key]; 10729 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(raw)) { 10730 const handler = ctx[raw]; 10731 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(handler)) { 10732 watch(getter, handler); 10733 } 10734 else if ((true)) { 10735 warn(`Invalid watch handler specified by key "${raw}"`, handler); 10736 } 10737 } 10738 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(raw)) { 10739 watch(getter, raw.bind(publicThis)); 10740 } 10741 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(raw)) { 10742 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) { 10743 raw.forEach(r => createWatcher(r, ctx, publicThis, key)); 10744 } 10745 else { 10746 const handler = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(raw.handler) 10747 ? raw.handler.bind(publicThis) 10748 : ctx[raw.handler]; 10749 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(handler)) { 10750 watch(getter, handler, raw); 10751 } 10752 else if ((true)) { 10753 warn(`Invalid watch handler specified by key "${raw.handler}"`, handler); 10754 } 10755 } 10756 } 10757 else if ((true)) { 10758 warn(`Invalid watch option: "${key}"`, raw); 10759 } 10760} 10761/** 10762 * Resolve merged options and cache it on the component. 10763 * This is done only once per-component since the merging does not involve 10764 * instances. 10765 */ 10766function resolveMergedOptions(instance) { 10767 const base = instance.type; 10768 const { mixins, extends: extendsOptions } = base; 10769 const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance.appContext; 10770 const cached = cache.get(base); 10771 let resolved; 10772 if (cached) { 10773 resolved = cached; 10774 } 10775 else if (!globalMixins.length && !mixins && !extendsOptions) { 10776 { 10777 resolved = base; 10778 } 10779 } 10780 else { 10781 resolved = {}; 10782 if (globalMixins.length) { 10783 globalMixins.forEach(m => mergeOptions(resolved, m, optionMergeStrategies, true)); 10784 } 10785 mergeOptions(resolved, base, optionMergeStrategies); 10786 } 10787 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(base)) { 10788 cache.set(base, resolved); 10789 } 10790 return resolved; 10791} 10792function mergeOptions(to, from, strats, asMixin = false) { 10793 const { mixins, extends: extendsOptions } = from; 10794 if (extendsOptions) { 10795 mergeOptions(to, extendsOptions, strats, true); 10796 } 10797 if (mixins) { 10798 mixins.forEach((m) => mergeOptions(to, m, strats, true)); 10799 } 10800 for (const key in from) { 10801 if (asMixin && key === 'expose') { 10802 ( true) && 10803 warn(`"expose" option is ignored when declared in mixins or extends. ` + 10804 `It should only be declared in the base component itself.`); 10805 } 10806 else { 10807 const strat = internalOptionMergeStrats[key] || (strats && strats[key]); 10808 to[key] = strat ? strat(to[key], from[key]) : from[key]; 10809 } 10810 } 10811 return to; 10812} 10813const internalOptionMergeStrats = { 10814 data: mergeDataFn, 10815 props: mergeObjectOptions, 10816 emits: mergeObjectOptions, 10817 // objects 10818 methods: mergeObjectOptions, 10819 computed: mergeObjectOptions, 10820 // lifecycle 10821 beforeCreate: mergeAsArray, 10822 created: mergeAsArray, 10823 beforeMount: mergeAsArray, 10824 mounted: mergeAsArray, 10825 beforeUpdate: mergeAsArray, 10826 updated: mergeAsArray, 10827 beforeDestroy: mergeAsArray, 10828 beforeUnmount: mergeAsArray, 10829 destroyed: mergeAsArray, 10830 unmounted: mergeAsArray, 10831 activated: mergeAsArray, 10832 deactivated: mergeAsArray, 10833 errorCaptured: mergeAsArray, 10834 serverPrefetch: mergeAsArray, 10835 // assets 10836 components: mergeObjectOptions, 10837 directives: mergeObjectOptions, 10838 // watch 10839 watch: mergeWatchOptions, 10840 // provide / inject 10841 provide: mergeDataFn, 10842 inject: mergeInject 10843}; 10844function mergeDataFn(to, from) { 10845 if (!from) { 10846 return to; 10847 } 10848 if (!to) { 10849 return from; 10850 } 10851 return function mergedDataFn() { 10852 return ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend))((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(to) ? to.call(this, this) : to, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(from) ? from.call(this, this) : from); 10853 }; 10854} 10855function mergeInject(to, from) { 10856 return mergeObjectOptions(normalizeInject(to), normalizeInject(from)); 10857} 10858function normalizeInject(raw) { 10859 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) { 10860 const res = {}; 10861 for (let i = 0; i < raw.length; i++) { 10862 res[raw[i]] = raw[i]; 10863 } 10864 return res; 10865 } 10866 return raw; 10867} 10868function mergeAsArray(to, from) { 10869 return to ? [...new Set([].concat(to, from))] : from; 10870} 10871function mergeObjectOptions(to, from) { 10872 return to ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(Object.create(null), to), from) : from; 10873} 10874function mergeWatchOptions(to, from) { 10875 if (!to) 10876 return from; 10877 if (!from) 10878 return to; 10879 const merged = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(Object.create(null), to); 10880 for (const key in from) { 10881 merged[key] = mergeAsArray(to[key], from[key]); 10882 } 10883 return merged; 10884} 10885 10886function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison 10887isSSR = false) { 10888 const props = {}; 10889 const attrs = {}; 10890 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(attrs, InternalObjectKey, 1); 10891 instance.propsDefaults = Object.create(null); 10892 setFullProps(instance, rawProps, props, attrs); 10893 // ensure all declared prop keys are present 10894 for (const key in instance.propsOptions[0]) { 10895 if (!(key in props)) { 10896 props[key] = undefined; 10897 } 10898 } 10899 // validation 10900 if ((true)) { 10901 validateProps(rawProps || {}, props, instance); 10902 } 10903 if (isStateful) { 10904 // stateful 10905 instance.props = isSSR ? props : (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReactive)(props); 10906 } 10907 else { 10908 if (!instance.type.props) { 10909 // functional w/ optional props, props === attrs 10910 instance.props = attrs; 10911 } 10912 else { 10913 // functional w/ declared props 10914 instance.props = props; 10915 } 10916 } 10917 instance.attrs = attrs; 10918} 10919function isInHmrContext(instance) { 10920 while (instance) { 10921 if (instance.type.__hmrId) 10922 return true; 10923 instance = instance.parent; 10924 } 10925} 10926function updateProps(instance, rawProps, rawPrevProps, optimized) { 10927 const { props, attrs, vnode: { patchFlag } } = instance; 10928 const rawCurrentProps = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props); 10929 const [options] = instance.propsOptions; 10930 let hasAttrsChanged = false; 10931 if ( 10932 // always force full diff in dev 10933 // - #1942 if hmr is enabled with sfc component 10934 // - vite#872 non-sfc component used by sfc component 10935 !(( true) && isInHmrContext(instance)) && 10936 (optimized || patchFlag > 0) && 10937 !(patchFlag & 16 /* PatchFlags.FULL_PROPS */)) { 10938 if (patchFlag & 8 /* PatchFlags.PROPS */) { 10939 // Compiler-generated props & no keys change, just set the updated 10940 // the props. 10941 const propsToUpdate = instance.vnode.dynamicProps; 10942 for (let i = 0; i < propsToUpdate.length; i++) { 10943 let key = propsToUpdate[i]; 10944 // skip if the prop key is a declared emit event listener 10945 if (isEmitListener(instance.emitsOptions, key)) { 10946 continue; 10947 } 10948 // PROPS flag guarantees rawProps to be non-null 10949 const value = rawProps[key]; 10950 if (options) { 10951 // attr / props separation was done on init and will be consistent 10952 // in this code path, so just check if attrs have it. 10953 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(attrs, key)) { 10954 if (value !== attrs[key]) { 10955 attrs[key] = value; 10956 hasAttrsChanged = true; 10957 } 10958 } 10959 else { 10960 const camelizedKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key); 10961 props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false /* isAbsent */); 10962 } 10963 } 10964 else { 10965 if (value !== attrs[key]) { 10966 attrs[key] = value; 10967 hasAttrsChanged = true; 10968 } 10969 } 10970 } 10971 } 10972 } 10973 else { 10974 // full props update. 10975 if (setFullProps(instance, rawProps, props, attrs)) { 10976 hasAttrsChanged = true; 10977 } 10978 // in case of dynamic props, check if we need to delete keys from 10979 // the props object 10980 let kebabKey; 10981 for (const key in rawCurrentProps) { 10982 if (!rawProps || 10983 // for camelCase 10984 (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, key) && 10985 // it's possible the original props was passed in as kebab-case 10986 // and converted to camelCase (#955) 10987 ((kebabKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key)) === key || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, kebabKey)))) { 10988 if (options) { 10989 if (rawPrevProps && 10990 // for camelCase 10991 (rawPrevProps[key] !== undefined || 10992 // for kebab-case 10993 rawPrevProps[kebabKey] !== undefined)) { 10994 props[key] = resolvePropValue(options, rawCurrentProps, key, undefined, instance, true /* isAbsent */); 10995 } 10996 } 10997 else { 10998 delete props[key]; 10999 } 11000 } 11001 } 11002 // in the case of functional component w/o props declaration, props and 11003 // attrs point to the same object so it should already have been updated. 11004 if (attrs !== rawCurrentProps) { 11005 for (const key in attrs) { 11006 if (!rawProps || 11007 (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, key) && 11008 (!false ))) { 11009 delete attrs[key]; 11010 hasAttrsChanged = true; 11011 } 11012 } 11013 } 11014 } 11015 // trigger updates for $attrs in case it's used in component slots 11016 if (hasAttrsChanged) { 11017 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.trigger)(instance, "set" /* TriggerOpTypes.SET */, '$attrs'); 11018 } 11019 if ((true)) { 11020 validateProps(rawProps || {}, props, instance); 11021 } 11022} 11023function setFullProps(instance, rawProps, props, attrs) { 11024 const [options, needCastKeys] = instance.propsOptions; 11025 let hasAttrsChanged = false; 11026 let rawCastValues; 11027 if (rawProps) { 11028 for (let key in rawProps) { 11029 // key, ref are reserved and never passed down 11030 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) { 11031 continue; 11032 } 11033 const value = rawProps[key]; 11034 // prop option names are camelized during normalization, so to support 11035 // kebab -> camel conversion here we need to camelize the key. 11036 let camelKey; 11037 if (options && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, (camelKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key)))) { 11038 if (!needCastKeys || !needCastKeys.includes(camelKey)) { 11039 props[camelKey] = value; 11040 } 11041 else { 11042 (rawCastValues || (rawCastValues = {}))[camelKey] = value; 11043 } 11044 } 11045 else if (!isEmitListener(instance.emitsOptions, key)) { 11046 if (!(key in attrs) || value !== attrs[key]) { 11047 attrs[key] = value; 11048 hasAttrsChanged = true; 11049 } 11050 } 11051 } 11052 } 11053 if (needCastKeys) { 11054 const rawCurrentProps = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props); 11055 const castValues = rawCastValues || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 11056 for (let i = 0; i < needCastKeys.length; i++) { 11057 const key = needCastKeys[i]; 11058 props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(castValues, key)); 11059 } 11060 } 11061 return hasAttrsChanged; 11062} 11063function resolvePropValue(options, props, key, value, instance, isAbsent) { 11064 const opt = options[key]; 11065 if (opt != null) { 11066 const hasDefault = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(opt, 'default'); 11067 // default values 11068 if (hasDefault && value === undefined) { 11069 const defaultValue = opt.default; 11070 if (opt.type !== Function && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(defaultValue)) { 11071 const { propsDefaults } = instance; 11072 if (key in propsDefaults) { 11073 value = propsDefaults[key]; 11074 } 11075 else { 11076 setCurrentInstance(instance); 11077 value = propsDefaults[key] = defaultValue.call(null, props); 11078 unsetCurrentInstance(); 11079 } 11080 } 11081 else { 11082 value = defaultValue; 11083 } 11084 } 11085 // boolean casting 11086 if (opt[0 /* BooleanFlags.shouldCast */]) { 11087 if (isAbsent && !hasDefault) { 11088 value = false; 11089 } 11090 else if (opt[1 /* BooleanFlags.shouldCastTrue */] && 11091 (value === '' || value === (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key))) { 11092 value = true; 11093 } 11094 } 11095 } 11096 return value; 11097} 11098function normalizePropsOptions(comp, appContext, asMixin = false) { 11099 const cache = appContext.propsCache; 11100 const cached = cache.get(comp); 11101 if (cached) { 11102 return cached; 11103 } 11104 const raw = comp.props; 11105 const normalized = {}; 11106 const needCastKeys = []; 11107 // apply mixin/extends props 11108 let hasExtends = false; 11109 if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(comp)) { 11110 const extendProps = (raw) => { 11111 hasExtends = true; 11112 const [props, keys] = normalizePropsOptions(raw, appContext, true); 11113 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(normalized, props); 11114 if (keys) 11115 needCastKeys.push(...keys); 11116 }; 11117 if (!asMixin && appContext.mixins.length) { 11118 appContext.mixins.forEach(extendProps); 11119 } 11120 if (comp.extends) { 11121 extendProps(comp.extends); 11122 } 11123 if (comp.mixins) { 11124 comp.mixins.forEach(extendProps); 11125 } 11126 } 11127 if (!raw && !hasExtends) { 11128 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) { 11129 cache.set(comp, _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR); 11130 } 11131 return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR; 11132 } 11133 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) { 11134 for (let i = 0; i < raw.length; i++) { 11135 if (( true) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(raw[i])) { 11136 warn(`props must be strings when using array syntax.`, raw[i]); 11137 } 11138 const normalizedKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(raw[i]); 11139 if (validatePropName(normalizedKey)) { 11140 normalized[normalizedKey] = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 11141 } 11142 } 11143 } 11144 else if (raw) { 11145 if (( true) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(raw)) { 11146 warn(`invalid props options`, raw); 11147 } 11148 for (const key in raw) { 11149 const normalizedKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key); 11150 if (validatePropName(normalizedKey)) { 11151 const opt = raw[key]; 11152 const prop = (normalized[normalizedKey] = 11153 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(opt) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt) ? { type: opt } : Object.assign({}, opt)); 11154 if (prop) { 11155 const booleanIndex = getTypeIndex(Boolean, prop.type); 11156 const stringIndex = getTypeIndex(String, prop.type); 11157 prop[0 /* BooleanFlags.shouldCast */] = booleanIndex > -1; 11158 prop[1 /* BooleanFlags.shouldCastTrue */] = 11159 stringIndex < 0 || booleanIndex < stringIndex; 11160 // if the prop needs boolean casting or default value 11161 if (booleanIndex > -1 || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(prop, 'default')) { 11162 needCastKeys.push(normalizedKey); 11163 } 11164 } 11165 } 11166 } 11167 } 11168 const res = [normalized, needCastKeys]; 11169 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) { 11170 cache.set(comp, res); 11171 } 11172 return res; 11173} 11174function validatePropName(key) { 11175 if (key[0] !== '$') { 11176 return true; 11177 } 11178 else if ((true)) { 11179 warn(`Invalid prop name: "${key}" is a reserved property.`); 11180 } 11181 return false; 11182} 11183// use function string name to check type constructors 11184// so that it works across vms / iframes. 11185function getType(ctor) { 11186 const match = ctor && ctor.toString().match(/^\s*function (\w+)/); 11187 return match ? match[1] : ctor === null ? 'null' : ''; 11188} 11189function isSameType(a, b) { 11190 return getType(a) === getType(b); 11191} 11192function getTypeIndex(type, expectedTypes) { 11193 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(expectedTypes)) { 11194 return expectedTypes.findIndex(t => isSameType(t, type)); 11195 } 11196 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(expectedTypes)) { 11197 return isSameType(expectedTypes, type) ? 0 : -1; 11198 } 11199 return -1; 11200} 11201/** 11202 * dev only 11203 */ 11204function validateProps(rawProps, props, instance) { 11205 const resolvedValues = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props); 11206 const options = instance.propsOptions[0]; 11207 for (const key in options) { 11208 let opt = options[key]; 11209 if (opt == null) 11210 continue; 11211 validateProp(key, resolvedValues[key], opt, !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, key) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key))); 11212 } 11213} 11214/** 11215 * dev only 11216 */ 11217function validateProp(name, value, prop, isAbsent) { 11218 const { type, required, validator } = prop; 11219 // required! 11220 if (required && isAbsent) { 11221 warn('Missing required prop: "' + name + '"'); 11222 return; 11223 } 11224 // missing but optional 11225 if (value == null && !prop.required) { 11226 return; 11227 } 11228 // type check 11229 if (type != null && type !== true) { 11230 let isValid = false; 11231 const types = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(type) ? type : [type]; 11232 const expectedTypes = []; 11233 // value is valid as long as one of the specified types match 11234 for (let i = 0; i < types.length && !isValid; i++) { 11235 const { valid, expectedType } = assertType(value, types[i]); 11236 expectedTypes.push(expectedType || ''); 11237 isValid = valid; 11238 } 11239 if (!isValid) { 11240 warn(getInvalidTypeMessage(name, value, expectedTypes)); 11241 return; 11242 } 11243 } 11244 // custom validator 11245 if (validator && !validator(value)) { 11246 warn('Invalid prop: custom validator check failed for prop "' + name + '".'); 11247 } 11248} 11249const isSimpleType = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)('String,Number,Boolean,Function,Symbol,BigInt'); 11250/** 11251 * dev only 11252 */ 11253function assertType(value, type) { 11254 let valid; 11255 const expectedType = getType(type); 11256 if (isSimpleType(expectedType)) { 11257 const t = typeof value; 11258 valid = t === expectedType.toLowerCase(); 11259 // for primitive wrapper objects 11260 if (!valid && t === 'object') { 11261 valid = value instanceof type; 11262 } 11263 } 11264 else if (expectedType === 'Object') { 11265 valid = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(value); 11266 } 11267 else if (expectedType === 'Array') { 11268 valid = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value); 11269 } 11270 else if (expectedType === 'null') { 11271 valid = value === null; 11272 } 11273 else { 11274 valid = value instanceof type; 11275 } 11276 return { 11277 valid, 11278 expectedType 11279 }; 11280} 11281/** 11282 * dev only 11283 */ 11284function getInvalidTypeMessage(name, value, expectedTypes) { 11285 let message = `Invalid prop: type check failed for prop "${name}".` + 11286 ` Expected ${expectedTypes.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize).join(' | ')}`; 11287 const expectedType = expectedTypes[0]; 11288 const receivedType = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toRawType)(value); 11289 const expectedValue = styleValue(value, expectedType); 11290 const receivedValue = styleValue(value, receivedType); 11291 // check if we need to specify expected value 11292 if (expectedTypes.length === 1 && 11293 isExplicable(expectedType) && 11294 !isBoolean(expectedType, receivedType)) { 11295 message += ` with value ${expectedValue}`; 11296 } 11297 message += `, got ${receivedType} `; 11298 // check if we need to specify received value 11299 if (isExplicable(receivedType)) { 11300 message += `with value ${receivedValue}.`; 11301 } 11302 return message; 11303} 11304/** 11305 * dev only 11306 */ 11307function styleValue(value, type) { 11308 if (type === 'String') { 11309 return `"${value}"`; 11310 } 11311 else if (type === 'Number') { 11312 return `${Number(value)}`; 11313 } 11314 else { 11315 return `${value}`; 11316 } 11317} 11318/** 11319 * dev only 11320 */ 11321function isExplicable(type) { 11322 const explicitTypes = ['string', 'number', 'boolean']; 11323 return explicitTypes.some(elem => type.toLowerCase() === elem); 11324} 11325/** 11326 * dev only 11327 */ 11328function isBoolean(...args) { 11329 return args.some(elem => elem.toLowerCase() === 'boolean'); 11330} 11331 11332const isInternalKey = (key) => key[0] === '_' || key === '$stable'; 11333const normalizeSlotValue = (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value) 11334 ? value.map(normalizeVNode) 11335 : [normalizeVNode(value)]; 11336const normalizeSlot = (key, rawSlot, ctx) => { 11337 if (rawSlot._n) { 11338 // already normalized - #5353 11339 return rawSlot; 11340 } 11341 const normalized = withCtx((...args) => { 11342 if (( true) && currentInstance) { 11343 warn(`Slot "${key}" invoked outside of the render function: ` + 11344 `this will not track dependencies used in the slot. ` + 11345 `Invoke the slot function inside the render function instead.`); 11346 } 11347 return normalizeSlotValue(rawSlot(...args)); 11348 }, ctx); 11349 normalized._c = false; 11350 return normalized; 11351}; 11352const normalizeObjectSlots = (rawSlots, slots, instance) => { 11353 const ctx = rawSlots._ctx; 11354 for (const key in rawSlots) { 11355 if (isInternalKey(key)) 11356 continue; 11357 const value = rawSlots[key]; 11358 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) { 11359 slots[key] = normalizeSlot(key, value, ctx); 11360 } 11361 else if (value != null) { 11362 if (true) { 11363 warn(`Non-function value encountered for slot "${key}". ` + 11364 `Prefer function slots for better performance.`); 11365 } 11366 const normalized = normalizeSlotValue(value); 11367 slots[key] = () => normalized; 11368 } 11369 } 11370}; 11371const normalizeVNodeSlots = (instance, children) => { 11372 if (( true) && 11373 !isKeepAlive(instance.vnode) && 11374 !(false )) { 11375 warn(`Non-function value encountered for default slot. ` + 11376 `Prefer function slots for better performance.`); 11377 } 11378 const normalized = normalizeSlotValue(children); 11379 instance.slots.default = () => normalized; 11380}; 11381const initSlots = (instance, children) => { 11382 if (instance.vnode.shapeFlag & 32 /* ShapeFlags.SLOTS_CHILDREN */) { 11383 const type = children._; 11384 if (type) { 11385 // users can get the shallow readonly version of the slots object through `this.$slots`, 11386 // we should avoid the proxy object polluting the slots of the internal instance 11387 instance.slots = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(children); 11388 // make compiler marker non-enumerable 11389 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(children, '_', type); 11390 } 11391 else { 11392 normalizeObjectSlots(children, (instance.slots = {})); 11393 } 11394 } 11395 else { 11396 instance.slots = {}; 11397 if (children) { 11398 normalizeVNodeSlots(instance, children); 11399 } 11400 } 11401 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(instance.slots, InternalObjectKey, 1); 11402}; 11403const updateSlots = (instance, children, optimized) => { 11404 const { vnode, slots } = instance; 11405 let needDeletionCheck = true; 11406 let deletionComparisonTarget = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 11407 if (vnode.shapeFlag & 32 /* ShapeFlags.SLOTS_CHILDREN */) { 11408 const type = children._; 11409 if (type) { 11410 // compiled slots. 11411 if (( true) && isHmrUpdating) { 11412 // Parent was HMR updated so slot content may have changed. 11413 // force update slots and mark instance for hmr as well 11414 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(slots, children); 11415 } 11416 else if (optimized && type === 1 /* SlotFlags.STABLE */) { 11417 // compiled AND stable. 11418 // no need to update, and skip stale slots removal. 11419 needDeletionCheck = false; 11420 } 11421 else { 11422 // compiled but dynamic (v-if/v-for on slots) - update slots, but skip 11423 // normalization. 11424 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(slots, children); 11425 // #2893 11426 // when rendering the optimized slots by manually written render function, 11427 // we need to delete the `slots._` flag if necessary to make subsequent updates reliable, 11428 // i.e. let the `renderSlot` create the bailed Fragment 11429 if (!optimized && type === 1 /* SlotFlags.STABLE */) { 11430 delete slots._; 11431 } 11432 } 11433 } 11434 else { 11435 needDeletionCheck = !children.$stable; 11436 normalizeObjectSlots(children, slots); 11437 } 11438 deletionComparisonTarget = children; 11439 } 11440 else if (children) { 11441 // non slot object children (direct value) passed to a component 11442 normalizeVNodeSlots(instance, children); 11443 deletionComparisonTarget = { default: 1 }; 11444 } 11445 // delete stale slots 11446 if (needDeletionCheck) { 11447 for (const key in slots) { 11448 if (!isInternalKey(key) && !(key in deletionComparisonTarget)) { 11449 delete slots[key]; 11450 } 11451 } 11452 } 11453}; 11454 11455function createAppContext() { 11456 return { 11457 app: null, 11458 config: { 11459 isNativeTag: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NO, 11460 performance: false, 11461 globalProperties: {}, 11462 optionMergeStrategies: {}, 11463 errorHandler: undefined, 11464 warnHandler: undefined, 11465 compilerOptions: {} 11466 }, 11467 mixins: [], 11468 components: {}, 11469 directives: {}, 11470 provides: Object.create(null), 11471 optionsCache: new WeakMap(), 11472 propsCache: new WeakMap(), 11473 emitsCache: new WeakMap() 11474 }; 11475} 11476let uid = 0; 11477function createAppAPI(render, hydrate) { 11478 return function createApp(rootComponent, rootProps = null) { 11479 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(rootComponent)) { 11480 rootComponent = Object.assign({}, rootComponent); 11481 } 11482 if (rootProps != null && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(rootProps)) { 11483 ( true) && warn(`root props passed to app.mount() must be an object.`); 11484 rootProps = null; 11485 } 11486 const context = createAppContext(); 11487 const installedPlugins = new Set(); 11488 let isMounted = false; 11489 const app = (context.app = { 11490 _uid: uid++, 11491 _component: rootComponent, 11492 _props: rootProps, 11493 _container: null, 11494 _context: context, 11495 _instance: null, 11496 version, 11497 get config() { 11498 return context.config; 11499 }, 11500 set config(v) { 11501 if ((true)) { 11502 warn(`app.config cannot be replaced. Modify individual options instead.`); 11503 } 11504 }, 11505 use(plugin, ...options) { 11506 if (installedPlugins.has(plugin)) { 11507 ( true) && warn(`Plugin has already been applied to target app.`); 11508 } 11509 else if (plugin && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(plugin.install)) { 11510 installedPlugins.add(plugin); 11511 plugin.install(app, ...options); 11512 } 11513 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(plugin)) { 11514 installedPlugins.add(plugin); 11515 plugin(app, ...options); 11516 } 11517 else if ((true)) { 11518 warn(`A plugin must either be a function or an object with an "install" ` + 11519 `function.`); 11520 } 11521 return app; 11522 }, 11523 mixin(mixin) { 11524 if (true) { 11525 if (!context.mixins.includes(mixin)) { 11526 context.mixins.push(mixin); 11527 } 11528 else if ((true)) { 11529 warn('Mixin has already been applied to target app' + 11530 (mixin.name ? `: ${mixin.name}` : '')); 11531 } 11532 } 11533 else {} 11534 return app; 11535 }, 11536 component(name, component) { 11537 if ((true)) { 11538 validateComponentName(name, context.config); 11539 } 11540 if (!component) { 11541 return context.components[name]; 11542 } 11543 if (( true) && context.components[name]) { 11544 warn(`Component "${name}" has already been registered in target app.`); 11545 } 11546 context.components[name] = component; 11547 return app; 11548 }, 11549 directive(name, directive) { 11550 if ((true)) { 11551 validateDirectiveName(name); 11552 } 11553 if (!directive) { 11554 return context.directives[name]; 11555 } 11556 if (( true) && context.directives[name]) { 11557 warn(`Directive "${name}" has already been registered in target app.`); 11558 } 11559 context.directives[name] = directive; 11560 return app; 11561 }, 11562 mount(rootContainer, isHydrate, isSVG) { 11563 if (!isMounted) { 11564 // #5571 11565 if (( true) && rootContainer.__vue_app__) { 11566 warn(`There is already an app instance mounted on the host container.\n` + 11567 ` If you want to mount another app on the same host container,` + 11568 ` you need to unmount the previous app by calling \`app.unmount()\` first.`); 11569 } 11570 const vnode = createVNode(rootComponent, rootProps); 11571 // store app context on the root VNode. 11572 // this will be set on the root instance on initial mount. 11573 vnode.appContext = context; 11574 // HMR root reload 11575 if ((true)) { 11576 context.reload = () => { 11577 render(cloneVNode(vnode), rootContainer, isSVG); 11578 }; 11579 } 11580 if (isHydrate && hydrate) { 11581 hydrate(vnode, rootContainer); 11582 } 11583 else { 11584 render(vnode, rootContainer, isSVG); 11585 } 11586 isMounted = true; 11587 app._container = rootContainer; 11588 rootContainer.__vue_app__ = app; 11589 if (true) { 11590 app._instance = vnode.component; 11591 devtoolsInitApp(app, version); 11592 } 11593 return getExposeProxy(vnode.component) || vnode.component.proxy; 11594 } 11595 else if ((true)) { 11596 warn(`App has already been mounted.\n` + 11597 `If you want to remount the same app, move your app creation logic ` + 11598 `into a factory function and create fresh app instances for each ` + 11599 `mount - e.g. \`const createMyApp = () => createApp(App)\``); 11600 } 11601 }, 11602 unmount() { 11603 if (isMounted) { 11604 render(null, app._container); 11605 if (true) { 11606 app._instance = null; 11607 devtoolsUnmountApp(app); 11608 } 11609 delete app._container.__vue_app__; 11610 } 11611 else if ((true)) { 11612 warn(`Cannot unmount an app that is not mounted.`); 11613 } 11614 }, 11615 provide(key, value) { 11616 if (( true) && key in context.provides) { 11617 warn(`App already provides property with key "${String(key)}". ` + 11618 `It will be overwritten with the new value.`); 11619 } 11620 context.provides[key] = value; 11621 return app; 11622 } 11623 }); 11624 return app; 11625 }; 11626} 11627 11628/** 11629 * Function for handling a template ref 11630 */ 11631function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) { 11632 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(rawRef)) { 11633 rawRef.forEach((r, i) => setRef(r, oldRawRef && ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount)); 11634 return; 11635 } 11636 if (isAsyncWrapper(vnode) && !isUnmount) { 11637 // when mounting async components, nothing needs to be done, 11638 // because the template ref is forwarded to inner component 11639 return; 11640 } 11641 const refValue = vnode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */ 11642 ? getExposeProxy(vnode.component) || vnode.component.proxy 11643 : vnode.el; 11644 const value = isUnmount ? null : refValue; 11645 const { i: owner, r: ref } = rawRef; 11646 if (( true) && !owner) { 11647 warn(`Missing ref owner context. ref cannot be used on hoisted vnodes. ` + 11648 `A vnode with ref must be created inside the render function.`); 11649 return; 11650 } 11651 const oldRef = oldRawRef && oldRawRef.r; 11652 const refs = owner.refs === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ ? (owner.refs = {}) : owner.refs; 11653 const setupState = owner.setupState; 11654 // dynamic ref changed. unset old ref 11655 if (oldRef != null && oldRef !== ref) { 11656 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(oldRef)) { 11657 refs[oldRef] = null; 11658 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, oldRef)) { 11659 setupState[oldRef] = null; 11660 } 11661 } 11662 else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(oldRef)) { 11663 oldRef.value = null; 11664 } 11665 } 11666 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(ref)) { 11667 callWithErrorHandling(ref, owner, 12 /* ErrorCodes.FUNCTION_REF */, [value, refs]); 11668 } 11669 else { 11670 const _isString = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(ref); 11671 const _isRef = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(ref); 11672 if (_isString || _isRef) { 11673 const doSet = () => { 11674 if (rawRef.f) { 11675 const existing = _isString 11676 ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, ref) 11677 ? setupState[ref] 11678 : refs[ref] 11679 : ref.value; 11680 if (isUnmount) { 11681 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(existing) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.remove)(existing, refValue); 11682 } 11683 else { 11684 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(existing)) { 11685 if (_isString) { 11686 refs[ref] = [refValue]; 11687 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, ref)) { 11688 setupState[ref] = refs[ref]; 11689 } 11690 } 11691 else { 11692 ref.value = [refValue]; 11693 if (rawRef.k) 11694 refs[rawRef.k] = ref.value; 11695 } 11696 } 11697 else if (!existing.includes(refValue)) { 11698 existing.push(refValue); 11699 } 11700 } 11701 } 11702 else if (_isString) { 11703 refs[ref] = value; 11704 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, ref)) { 11705 setupState[ref] = value; 11706 } 11707 } 11708 else if (_isRef) { 11709 ref.value = value; 11710 if (rawRef.k) 11711 refs[rawRef.k] = value; 11712 } 11713 else if ((true)) { 11714 warn('Invalid template ref type:', ref, `(${typeof ref})`); 11715 } 11716 }; 11717 if (value) { 11718 doSet.id = -1; 11719 queuePostRenderEffect(doSet, parentSuspense); 11720 } 11721 else { 11722 doSet(); 11723 } 11724 } 11725 else if ((true)) { 11726 warn('Invalid template ref type:', ref, `(${typeof ref})`); 11727 } 11728 } 11729} 11730 11731let hasMismatch = false; 11732const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject'; 11733const isComment = (node) => node.nodeType === 8 /* DOMNodeTypes.COMMENT */; 11734// Note: hydration is DOM-specific 11735// But we have to place it in core due to tight coupling with core - splitting 11736// it out creates a ton of unnecessary complexity. 11737// Hydration also depends on some renderer internal logic which needs to be 11738// passed in via arguments. 11739function createHydrationFunctions(rendererInternals) { 11740 const { mt: mountComponent, p: patch, o: { patchProp, createText, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals; 11741 const hydrate = (vnode, container) => { 11742 if (!container.hasChildNodes()) { 11743 ( true) && 11744 warn(`Attempting to hydrate existing markup but container is empty. ` + 11745 `Performing full mount instead.`); 11746 patch(null, vnode, container); 11747 flushPostFlushCbs(); 11748 container._vnode = vnode; 11749 return; 11750 } 11751 hasMismatch = false; 11752 hydrateNode(container.firstChild, vnode, null, null, null); 11753 flushPostFlushCbs(); 11754 container._vnode = vnode; 11755 if (hasMismatch && !false) { 11756 // this error should show up in production 11757 console.error(`Hydration completed but contains mismatches.`); 11758 } 11759 }; 11760 const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => { 11761 const isFragmentStart = isComment(node) && node.data === '['; 11762 const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart); 11763 const { type, ref, shapeFlag, patchFlag } = vnode; 11764 let domType = node.nodeType; 11765 vnode.el = node; 11766 if (patchFlag === -2 /* PatchFlags.BAIL */) { 11767 optimized = false; 11768 vnode.dynamicChildren = null; 11769 } 11770 let nextNode = null; 11771 switch (type) { 11772 case Text: 11773 if (domType !== 3 /* DOMNodeTypes.TEXT */) { 11774 // #5728 empty text node inside a slot can cause hydration failure 11775 // because the server rendered HTML won't contain a text node 11776 if (vnode.children === '') { 11777 insert((vnode.el = createText('')), parentNode(node), node); 11778 nextNode = node; 11779 } 11780 else { 11781 nextNode = onMismatch(); 11782 } 11783 } 11784 else { 11785 if (node.data !== vnode.children) { 11786 hasMismatch = true; 11787 ( true) && 11788 warn(`Hydration text mismatch:` + 11789 `\n- Client: ${JSON.stringify(node.data)}` + 11790 `\n- Server: ${JSON.stringify(vnode.children)}`); 11791 node.data = vnode.children; 11792 } 11793 nextNode = nextSibling(node); 11794 } 11795 break; 11796 case Comment: 11797 if (domType !== 8 /* DOMNodeTypes.COMMENT */ || isFragmentStart) { 11798 nextNode = onMismatch(); 11799 } 11800 else { 11801 nextNode = nextSibling(node); 11802 } 11803 break; 11804 case Static: 11805 if (isFragmentStart) { 11806 // entire template is static but SSRed as a fragment 11807 node = nextSibling(node); 11808 domType = node.nodeType; 11809 } 11810 if (domType === 1 /* DOMNodeTypes.ELEMENT */ || domType === 3 /* DOMNodeTypes.TEXT */) { 11811 // determine anchor, adopt content 11812 nextNode = node; 11813 // if the static vnode has its content stripped during build, 11814 // adopt it from the server-rendered HTML. 11815 const needToAdoptContent = !vnode.children.length; 11816 for (let i = 0; i < vnode.staticCount; i++) { 11817 if (needToAdoptContent) 11818 vnode.children += 11819 nextNode.nodeType === 1 /* DOMNodeTypes.ELEMENT */ 11820 ? nextNode.outerHTML 11821 : nextNode.data; 11822 if (i === vnode.staticCount - 1) { 11823 vnode.anchor = nextNode; 11824 } 11825 nextNode = nextSibling(nextNode); 11826 } 11827 return isFragmentStart ? nextSibling(nextNode) : nextNode; 11828 } 11829 else { 11830 onMismatch(); 11831 } 11832 break; 11833 case Fragment: 11834 if (!isFragmentStart) { 11835 nextNode = onMismatch(); 11836 } 11837 else { 11838 nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); 11839 } 11840 break; 11841 default: 11842 if (shapeFlag & 1 /* ShapeFlags.ELEMENT */) { 11843 if (domType !== 1 /* DOMNodeTypes.ELEMENT */ || 11844 vnode.type.toLowerCase() !== 11845 node.tagName.toLowerCase()) { 11846 nextNode = onMismatch(); 11847 } 11848 else { 11849 nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); 11850 } 11851 } 11852 else if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) { 11853 // when setting up the render effect, if the initial vnode already 11854 // has .el set, the component will perform hydration instead of mount 11855 // on its sub-tree. 11856 vnode.slotScopeIds = slotScopeIds; 11857 const container = parentNode(node); 11858 mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized); 11859 // component may be async, so in the case of fragments we cannot rely 11860 // on component's rendered output to determine the end of the fragment 11861 // instead, we do a lookahead to find the end anchor node. 11862 nextNode = isFragmentStart 11863 ? locateClosingAsyncAnchor(node) 11864 : nextSibling(node); 11865 // #4293 teleport as component root 11866 if (nextNode && 11867 isComment(nextNode) && 11868 nextNode.data === 'teleport end') { 11869 nextNode = nextSibling(nextNode); 11870 } 11871 // #3787 11872 // if component is async, it may get moved / unmounted before its 11873 // inner component is loaded, so we need to give it a placeholder 11874 // vnode that matches its adopted DOM. 11875 if (isAsyncWrapper(vnode)) { 11876 let subTree; 11877 if (isFragmentStart) { 11878 subTree = createVNode(Fragment); 11879 subTree.anchor = nextNode 11880 ? nextNode.previousSibling 11881 : container.lastChild; 11882 } 11883 else { 11884 subTree = 11885 node.nodeType === 3 ? createTextVNode('') : createVNode('div'); 11886 } 11887 subTree.el = node; 11888 vnode.component.subTree = subTree; 11889 } 11890 } 11891 else if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) { 11892 if (domType !== 8 /* DOMNodeTypes.COMMENT */) { 11893 nextNode = onMismatch(); 11894 } 11895 else { 11896 nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren); 11897 } 11898 } 11899 else if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) { 11900 nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode); 11901 } 11902 else if ((true)) { 11903 warn('Invalid HostVNode type:', type, `(${typeof type})`); 11904 } 11905 } 11906 if (ref != null) { 11907 setRef(ref, null, parentSuspense, vnode); 11908 } 11909 return nextNode; 11910 }; 11911 const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { 11912 optimized = optimized || !!vnode.dynamicChildren; 11913 const { type, props, patchFlag, shapeFlag, dirs } = vnode; 11914 // #4006 for form elements with non-string v-model value bindings 11915 // e.g. <option :value="obj">, <input type="checkbox" :true-value="1"> 11916 const forcePatchValue = (type === 'input' && dirs) || type === 'option'; 11917 // skip props & children if this is hoisted static nodes 11918 // #5405 in dev, always hydrate children for HMR 11919 if (true /* PatchFlags.HOISTED */) { 11920 if (dirs) { 11921 invokeDirectiveHook(vnode, null, parentComponent, 'created'); 11922 } 11923 // props 11924 if (props) { 11925 if (forcePatchValue || 11926 !optimized || 11927 patchFlag & (16 /* PatchFlags.FULL_PROPS */ | 32 /* PatchFlags.HYDRATE_EVENTS */)) { 11928 for (const key in props) { 11929 if ((forcePatchValue && key.endsWith('value')) || 11930 ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key))) { 11931 patchProp(el, key, null, props[key], false, undefined, parentComponent); 11932 } 11933 } 11934 } 11935 else if (props.onClick) { 11936 // Fast path for click listeners (which is most often) to avoid 11937 // iterating through props. 11938 patchProp(el, 'onClick', null, props.onClick, false, undefined, parentComponent); 11939 } 11940 } 11941 // vnode / directive hooks 11942 let vnodeHooks; 11943 if ((vnodeHooks = props && props.onVnodeBeforeMount)) { 11944 invokeVNodeHook(vnodeHooks, parentComponent, vnode); 11945 } 11946 if (dirs) { 11947 invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount'); 11948 } 11949 if ((vnodeHooks = props && props.onVnodeMounted) || dirs) { 11950 queueEffectWithSuspense(() => { 11951 vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode); 11952 dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted'); 11953 }, parentSuspense); 11954 } 11955 // children 11956 if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */ && 11957 // skip if element has innerHTML / textContent 11958 !(props && (props.innerHTML || props.textContent))) { 11959 let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, slotScopeIds, optimized); 11960 let hasWarned = false; 11961 while (next) { 11962 hasMismatch = true; 11963 if (( true) && !hasWarned) { 11964 warn(`Hydration children mismatch in <${vnode.type}>: ` + 11965 `server rendered element contains more child nodes than client vdom.`); 11966 hasWarned = true; 11967 } 11968 // The SSRed DOM contains more nodes than it should. Remove them. 11969 const cur = next; 11970 next = next.nextSibling; 11971 remove(cur); 11972 } 11973 } 11974 else if (shapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) { 11975 if (el.textContent !== vnode.children) { 11976 hasMismatch = true; 11977 ( true) && 11978 warn(`Hydration text content mismatch in <${vnode.type}>:\n` + 11979 `- Client: ${el.textContent}\n` + 11980 `- Server: ${vnode.children}`); 11981 el.textContent = vnode.children; 11982 } 11983 } 11984 } 11985 return el.nextSibling; 11986 }; 11987 const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => { 11988 optimized = optimized || !!parentVNode.dynamicChildren; 11989 const children = parentVNode.children; 11990 const l = children.length; 11991 let hasWarned = false; 11992 for (let i = 0; i < l; i++) { 11993 const vnode = optimized 11994 ? children[i] 11995 : (children[i] = normalizeVNode(children[i])); 11996 if (node) { 11997 node = hydrateNode(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); 11998 } 11999 else if (vnode.type === Text && !vnode.children) { 12000 continue; 12001 } 12002 else { 12003 hasMismatch = true; 12004 if (( true) && !hasWarned) { 12005 warn(`Hydration children mismatch in <${container.tagName.toLowerCase()}>: ` + 12006 `server rendered element contains fewer child nodes than client vdom.`); 12007 hasWarned = true; 12008 } 12009 // the SSRed DOM didn't contain enough nodes. Mount the missing ones. 12010 patch(null, vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), slotScopeIds); 12011 } 12012 } 12013 return node; 12014 }; 12015 const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { 12016 const { slotScopeIds: fragmentSlotScopeIds } = vnode; 12017 if (fragmentSlotScopeIds) { 12018 slotScopeIds = slotScopeIds 12019 ? slotScopeIds.concat(fragmentSlotScopeIds) 12020 : fragmentSlotScopeIds; 12021 } 12022 const container = parentNode(node); 12023 const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized); 12024 if (next && isComment(next) && next.data === ']') { 12025 return nextSibling((vnode.anchor = next)); 12026 } 12027 else { 12028 // fragment didn't hydrate successfully, since we didn't get a end anchor 12029 // back. This should have led to node/children mismatch warnings. 12030 hasMismatch = true; 12031 // since the anchor is missing, we need to create one and insert it 12032 insert((vnode.anchor = createComment(`]`)), container, next); 12033 return next; 12034 } 12035 }; 12036 const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => { 12037 hasMismatch = true; 12038 ( true) && 12039 warn(`Hydration node mismatch:\n- Client vnode:`, vnode.type, `\n- Server rendered DOM:`, node, node.nodeType === 3 /* DOMNodeTypes.TEXT */ 12040 ? `(text)` 12041 : isComment(node) && node.data === '[' 12042 ? `(start of fragment)` 12043 : ``); 12044 vnode.el = null; 12045 if (isFragment) { 12046 // remove excessive fragment nodes 12047 const end = locateClosingAsyncAnchor(node); 12048 while (true) { 12049 const next = nextSibling(node); 12050 if (next && next !== end) { 12051 remove(next); 12052 } 12053 else { 12054 break; 12055 } 12056 } 12057 } 12058 const next = nextSibling(node); 12059 const container = parentNode(node); 12060 remove(node); 12061 patch(null, vnode, container, next, parentComponent, parentSuspense, isSVGContainer(container), slotScopeIds); 12062 return next; 12063 }; 12064 const locateClosingAsyncAnchor = (node) => { 12065 let match = 0; 12066 while (node) { 12067 node = nextSibling(node); 12068 if (node && isComment(node)) { 12069 if (node.data === '[') 12070 match++; 12071 if (node.data === ']') { 12072 if (match === 0) { 12073 return nextSibling(node); 12074 } 12075 else { 12076 match--; 12077 } 12078 } 12079 } 12080 } 12081 return node; 12082 }; 12083 return [hydrate, hydrateNode]; 12084} 12085 12086/* eslint-disable no-restricted-globals */ 12087let supported; 12088let perf; 12089function startMeasure(instance, type) { 12090 if (instance.appContext.config.performance && isSupported()) { 12091 perf.mark(`vue-${type}-${instance.uid}`); 12092 } 12093 if (true) { 12094 devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now()); 12095 } 12096} 12097function endMeasure(instance, type) { 12098 if (instance.appContext.config.performance && isSupported()) { 12099 const startTag = `vue-${type}-${instance.uid}`; 12100 const endTag = startTag + `:end`; 12101 perf.mark(endTag); 12102 perf.measure(`<${formatComponentName(instance, instance.type)}> ${type}`, startTag, endTag); 12103 perf.clearMarks(startTag); 12104 perf.clearMarks(endTag); 12105 } 12106 if (true) { 12107 devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now()); 12108 } 12109} 12110function isSupported() { 12111 if (supported !== undefined) { 12112 return supported; 12113 } 12114 if (typeof window !== 'undefined' && window.performance) { 12115 supported = true; 12116 perf = window.performance; 12117 } 12118 else { 12119 supported = false; 12120 } 12121 return supported; 12122} 12123 12124/** 12125 * This is only called in esm-bundler builds. 12126 * It is called when a renderer is created, in `baseCreateRenderer` so that 12127 * importing runtime-core is side-effects free. 12128 * 12129 * istanbul-ignore-next 12130 */ 12131function initFeatureFlags() { 12132 const needWarn = []; 12133 if (false) {} 12134 if (false) {} 12135 if (( true) && needWarn.length) { 12136 const multi = needWarn.length > 1; 12137 console.warn(`Feature flag${multi ? `s` : ``} ${needWarn.join(', ')} ${multi ? `are` : `is`} not explicitly defined. You are running the esm-bundler build of Vue, ` + 12138 `which expects these compile-time feature flags to be globally injected ` + 12139 `via the bundler config in order to get better tree-shaking in the ` + 12140 `production bundle.\n\n` + 12141 `For more details, see https://link.vuejs.org/feature-flags.`); 12142 } 12143} 12144 12145const queuePostRenderEffect = queueEffectWithSuspense 12146 ; 12147/** 12148 * The createRenderer function accepts two generic arguments: 12149 * HostNode and HostElement, corresponding to Node and Element types in the 12150 * host environment. For example, for runtime-dom, HostNode would be the DOM 12151 * `Node` interface and HostElement would be the DOM `Element` interface. 12152 * 12153 * Custom renderers can pass in the platform specific types like this: 12154 * 12155 * ``` js 12156 * const { render, createApp } = createRenderer<Node, Element>({ 12157 * patchProp, 12158 * ...nodeOps 12159 * }) 12160 * ``` 12161 */ 12162function createRenderer(options) { 12163 return baseCreateRenderer(options); 12164} 12165// Separate API for creating hydration-enabled renderer. 12166// Hydration logic is only used when calling this function, making it 12167// tree-shakable. 12168function createHydrationRenderer(options) { 12169 return baseCreateRenderer(options, createHydrationFunctions); 12170} 12171// implementation 12172function baseCreateRenderer(options, createHydrationFns) { 12173 // compile-time feature flags check 12174 { 12175 initFeatureFlags(); 12176 } 12177 const target = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)(); 12178 target.__VUE__ = true; 12179 if (true) { 12180 setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target); 12181 } 12182 const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP, insertStaticContent: hostInsertStaticContent } = options; 12183 // Note: functions inside this closure should use `const xxx = () => {}` 12184 // style in order to prevent being inlined by minifiers. 12185 const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = ( true) && isHmrUpdating ? false : !!n2.dynamicChildren) => { 12186 if (n1 === n2) { 12187 return; 12188 } 12189 // patching & not same type, unmount old tree 12190 if (n1 && !isSameVNodeType(n1, n2)) { 12191 anchor = getNextHostNode(n1); 12192 unmount(n1, parentComponent, parentSuspense, true); 12193 n1 = null; 12194 } 12195 if (n2.patchFlag === -2 /* PatchFlags.BAIL */) { 12196 optimized = false; 12197 n2.dynamicChildren = null; 12198 } 12199 const { type, ref, shapeFlag } = n2; 12200 switch (type) { 12201 case Text: 12202 processText(n1, n2, container, anchor); 12203 break; 12204 case Comment: 12205 processCommentNode(n1, n2, container, anchor); 12206 break; 12207 case Static: 12208 if (n1 == null) { 12209 mountStaticNode(n2, container, anchor, isSVG); 12210 } 12211 else if ((true)) { 12212 patchStaticNode(n1, n2, container, isSVG); 12213 } 12214 break; 12215 case Fragment: 12216 processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12217 break; 12218 default: 12219 if (shapeFlag & 1 /* ShapeFlags.ELEMENT */) { 12220 processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12221 } 12222 else if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) { 12223 processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12224 } 12225 else if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) { 12226 type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals); 12227 } 12228 else if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) { 12229 type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals); 12230 } 12231 else if ((true)) { 12232 warn('Invalid VNode type:', type, `(${typeof type})`); 12233 } 12234 } 12235 // set ref 12236 if (ref != null && parentComponent) { 12237 setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2); 12238 } 12239 }; 12240 const processText = (n1, n2, container, anchor) => { 12241 if (n1 == null) { 12242 hostInsert((n2.el = hostCreateText(n2.children)), container, anchor); 12243 } 12244 else { 12245 const el = (n2.el = n1.el); 12246 if (n2.children !== n1.children) { 12247 hostSetText(el, n2.children); 12248 } 12249 } 12250 }; 12251 const processCommentNode = (n1, n2, container, anchor) => { 12252 if (n1 == null) { 12253 hostInsert((n2.el = hostCreateComment(n2.children || '')), container, anchor); 12254 } 12255 else { 12256 // there's no support for dynamic comments 12257 n2.el = n1.el; 12258 } 12259 }; 12260 const mountStaticNode = (n2, container, anchor, isSVG) => { 12261 [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG, n2.el, n2.anchor); 12262 }; 12263 /** 12264 * Dev / HMR only 12265 */ 12266 const patchStaticNode = (n1, n2, container, isSVG) => { 12267 // static nodes are only patched during dev for HMR 12268 if (n2.children !== n1.children) { 12269 const anchor = hostNextSibling(n1.anchor); 12270 // remove existing 12271 removeStaticNode(n1); 12272 [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG); 12273 } 12274 else { 12275 n2.el = n1.el; 12276 n2.anchor = n1.anchor; 12277 } 12278 }; 12279 const moveStaticNode = ({ el, anchor }, container, nextSibling) => { 12280 let next; 12281 while (el && el !== anchor) { 12282 next = hostNextSibling(el); 12283 hostInsert(el, container, nextSibling); 12284 el = next; 12285 } 12286 hostInsert(anchor, container, nextSibling); 12287 }; 12288 const removeStaticNode = ({ el, anchor }) => { 12289 let next; 12290 while (el && el !== anchor) { 12291 next = hostNextSibling(el); 12292 hostRemove(el); 12293 el = next; 12294 } 12295 hostRemove(anchor); 12296 }; 12297 const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { 12298 isSVG = isSVG || n2.type === 'svg'; 12299 if (n1 == null) { 12300 mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12301 } 12302 else { 12303 patchElement(n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12304 } 12305 }; 12306 const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { 12307 let el; 12308 let vnodeHook; 12309 const { type, props, shapeFlag, transition, dirs } = vnode; 12310 el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is, props); 12311 // mount children first, since some props may rely on child content 12312 // being already rendered, e.g. `<select value>` 12313 if (shapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) { 12314 hostSetElementText(el, vnode.children); 12315 } 12316 else if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) { 12317 mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG && type !== 'foreignObject', slotScopeIds, optimized); 12318 } 12319 if (dirs) { 12320 invokeDirectiveHook(vnode, null, parentComponent, 'created'); 12321 } 12322 // props 12323 if (props) { 12324 for (const key in props) { 12325 if (key !== 'value' && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) { 12326 hostPatchProp(el, key, null, props[key], isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren); 12327 } 12328 } 12329 /** 12330 * Special case for setting value on DOM elements: 12331 * - it can be order-sensitive (e.g. should be set *after* min/max, #2325, #4024) 12332 * - it needs to be forced (#1471) 12333 * #2353 proposes adding another renderer option to configure this, but 12334 * the properties affects are so finite it is worth special casing it 12335 * here to reduce the complexity. (Special casing it also should not 12336 * affect non-DOM renderers) 12337 */ 12338 if ('value' in props) { 12339 hostPatchProp(el, 'value', null, props.value); 12340 } 12341 if ((vnodeHook = props.onVnodeBeforeMount)) { 12342 invokeVNodeHook(vnodeHook, parentComponent, vnode); 12343 } 12344 } 12345 // scopeId 12346 setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent); 12347 if (true) { 12348 Object.defineProperty(el, '__vnode', { 12349 value: vnode, 12350 enumerable: false 12351 }); 12352 Object.defineProperty(el, '__vueParentComponent', { 12353 value: parentComponent, 12354 enumerable: false 12355 }); 12356 } 12357 if (dirs) { 12358 invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount'); 12359 } 12360 // #1583 For inside suspense + suspense not resolved case, enter hook should call when suspense resolved 12361 // #1689 For inside suspense + suspense resolved case, just call it 12362 const needCallTransitionHooks = (!parentSuspense || (parentSuspense && !parentSuspense.pendingBranch)) && 12363 transition && 12364 !transition.persisted; 12365 if (needCallTransitionHooks) { 12366 transition.beforeEnter(el); 12367 } 12368 hostInsert(el, container, anchor); 12369 if ((vnodeHook = props && props.onVnodeMounted) || 12370 needCallTransitionHooks || 12371 dirs) { 12372 queuePostRenderEffect(() => { 12373 vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode); 12374 needCallTransitionHooks && transition.enter(el); 12375 dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted'); 12376 }, parentSuspense); 12377 } 12378 }; 12379 const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => { 12380 if (scopeId) { 12381 hostSetScopeId(el, scopeId); 12382 } 12383 if (slotScopeIds) { 12384 for (let i = 0; i < slotScopeIds.length; i++) { 12385 hostSetScopeId(el, slotScopeIds[i]); 12386 } 12387 } 12388 if (parentComponent) { 12389 let subTree = parentComponent.subTree; 12390 if (( true) && 12391 subTree.patchFlag > 0 && 12392 subTree.patchFlag & 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */) { 12393 subTree = 12394 filterSingleRoot(subTree.children) || subTree; 12395 } 12396 if (vnode === subTree) { 12397 const parentVNode = parentComponent.vnode; 12398 setScopeId(el, parentVNode, parentVNode.scopeId, parentVNode.slotScopeIds, parentComponent.parent); 12399 } 12400 } 12401 }; 12402 const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, start = 0) => { 12403 for (let i = start; i < children.length; i++) { 12404 const child = (children[i] = optimized 12405 ? cloneIfMounted(children[i]) 12406 : normalizeVNode(children[i])); 12407 patch(null, child, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12408 } 12409 }; 12410 const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { 12411 const el = (n2.el = n1.el); 12412 let { patchFlag, dynamicChildren, dirs } = n2; 12413 // #1426 take the old vnode's patch flag into account since user may clone a 12414 // compiler-generated vnode, which de-opts to FULL_PROPS 12415 patchFlag |= n1.patchFlag & 16 /* PatchFlags.FULL_PROPS */; 12416 const oldProps = n1.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 12417 const newProps = n2.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 12418 let vnodeHook; 12419 // disable recurse in beforeUpdate hooks 12420 parentComponent && toggleRecurse(parentComponent, false); 12421 if ((vnodeHook = newProps.onVnodeBeforeUpdate)) { 12422 invokeVNodeHook(vnodeHook, parentComponent, n2, n1); 12423 } 12424 if (dirs) { 12425 invokeDirectiveHook(n2, n1, parentComponent, 'beforeUpdate'); 12426 } 12427 parentComponent && toggleRecurse(parentComponent, true); 12428 if (( true) && isHmrUpdating) { 12429 // HMR updated, force full diff 12430 patchFlag = 0; 12431 optimized = false; 12432 dynamicChildren = null; 12433 } 12434 const areChildrenSVG = isSVG && n2.type !== 'foreignObject'; 12435 if (dynamicChildren) { 12436 patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, areChildrenSVG, slotScopeIds); 12437 if (( true) && parentComponent && parentComponent.type.__hmrId) { 12438 traverseStaticChildren(n1, n2); 12439 } 12440 } 12441 else if (!optimized) { 12442 // full diff 12443 patchChildren(n1, n2, el, null, parentComponent, parentSuspense, areChildrenSVG, slotScopeIds, false); 12444 } 12445 if (patchFlag > 0) { 12446 // the presence of a patchFlag means this element's render code was 12447 // generated by the compiler and can take the fast path. 12448 // in this path old node and new node are guaranteed to have the same shape 12449 // (i.e. at the exact same position in the source template) 12450 if (patchFlag & 16 /* PatchFlags.FULL_PROPS */) { 12451 // element props contain dynamic keys, full diff needed 12452 patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG); 12453 } 12454 else { 12455 // class 12456 // this flag is matched when the element has dynamic class bindings. 12457 if (patchFlag & 2 /* PatchFlags.CLASS */) { 12458 if (oldProps.class !== newProps.class) { 12459 hostPatchProp(el, 'class', null, newProps.class, isSVG); 12460 } 12461 } 12462 // style 12463 // this flag is matched when the element has dynamic style bindings 12464 if (patchFlag & 4 /* PatchFlags.STYLE */) { 12465 hostPatchProp(el, 'style', oldProps.style, newProps.style, isSVG); 12466 } 12467 // props 12468 // This flag is matched when the element has dynamic prop/attr bindings 12469 // other than class and style. The keys of dynamic prop/attrs are saved for 12470 // faster iteration. 12471 // Note dynamic keys like :[foo]="bar" will cause this optimization to 12472 // bail out and go through a full diff because we need to unset the old key 12473 if (patchFlag & 8 /* PatchFlags.PROPS */) { 12474 // if the flag is present then dynamicProps must be non-null 12475 const propsToUpdate = n2.dynamicProps; 12476 for (let i = 0; i < propsToUpdate.length; i++) { 12477 const key = propsToUpdate[i]; 12478 const prev = oldProps[key]; 12479 const next = newProps[key]; 12480 // #1471 force patch value 12481 if (next !== prev || key === 'value') { 12482 hostPatchProp(el, key, prev, next, isSVG, n1.children, parentComponent, parentSuspense, unmountChildren); 12483 } 12484 } 12485 } 12486 } 12487 // text 12488 // This flag is matched when the element has only dynamic text children. 12489 if (patchFlag & 1 /* PatchFlags.TEXT */) { 12490 if (n1.children !== n2.children) { 12491 hostSetElementText(el, n2.children); 12492 } 12493 } 12494 } 12495 else if (!optimized && dynamicChildren == null) { 12496 // unoptimized, full diff 12497 patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG); 12498 } 12499 if ((vnodeHook = newProps.onVnodeUpdated) || dirs) { 12500 queuePostRenderEffect(() => { 12501 vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1); 12502 dirs && invokeDirectiveHook(n2, n1, parentComponent, 'updated'); 12503 }, parentSuspense); 12504 } 12505 }; 12506 // The fast path for blocks. 12507 const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG, slotScopeIds) => { 12508 for (let i = 0; i < newChildren.length; i++) { 12509 const oldVNode = oldChildren[i]; 12510 const newVNode = newChildren[i]; 12511 // Determine the container (parent element) for the patch. 12512 const container = 12513 // oldVNode may be an errored async setup() component inside Suspense 12514 // which will not have a mounted element 12515 oldVNode.el && 12516 // - In the case of a Fragment, we need to provide the actual parent 12517 // of the Fragment itself so it can move its children. 12518 (oldVNode.type === Fragment || 12519 // - In the case of different nodes, there is going to be a replacement 12520 // which also requires the correct parent container 12521 !isSameVNodeType(oldVNode, newVNode) || 12522 // - In the case of a component, it could contain anything. 12523 oldVNode.shapeFlag & (6 /* ShapeFlags.COMPONENT */ | 64 /* ShapeFlags.TELEPORT */)) 12524 ? hostParentNode(oldVNode.el) 12525 : // In other cases, the parent container is not actually used so we 12526 // just pass the block element here to avoid a DOM parentNode call. 12527 fallbackContainer; 12528 patch(oldVNode, newVNode, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, true); 12529 } 12530 }; 12531 const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => { 12532 if (oldProps !== newProps) { 12533 if (oldProps !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) { 12534 for (const key in oldProps) { 12535 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key) && !(key in newProps)) { 12536 hostPatchProp(el, key, oldProps[key], null, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren); 12537 } 12538 } 12539 } 12540 for (const key in newProps) { 12541 // empty string is not valid prop 12542 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) 12543 continue; 12544 const next = newProps[key]; 12545 const prev = oldProps[key]; 12546 // defer patching value 12547 if (next !== prev && key !== 'value') { 12548 hostPatchProp(el, key, prev, next, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren); 12549 } 12550 } 12551 if ('value' in newProps) { 12552 hostPatchProp(el, 'value', oldProps.value, newProps.value); 12553 } 12554 } 12555 }; 12556 const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { 12557 const fragmentStartAnchor = (n2.el = n1 ? n1.el : hostCreateText('')); 12558 const fragmentEndAnchor = (n2.anchor = n1 ? n1.anchor : hostCreateText('')); 12559 let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2; 12560 if (( true) && 12561 // #5523 dev root fragment may inherit directives 12562 (isHmrUpdating || patchFlag & 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */)) { 12563 // HMR updated / Dev root fragment (w/ comments), force full diff 12564 patchFlag = 0; 12565 optimized = false; 12566 dynamicChildren = null; 12567 } 12568 // check if this is a slot fragment with :slotted scope ids 12569 if (fragmentSlotScopeIds) { 12570 slotScopeIds = slotScopeIds 12571 ? slotScopeIds.concat(fragmentSlotScopeIds) 12572 : fragmentSlotScopeIds; 12573 } 12574 if (n1 == null) { 12575 hostInsert(fragmentStartAnchor, container, anchor); 12576 hostInsert(fragmentEndAnchor, container, anchor); 12577 // a fragment can only have array children 12578 // since they are either generated by the compiler, or implicitly created 12579 // from arrays. 12580 mountChildren(n2.children, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12581 } 12582 else { 12583 if (patchFlag > 0 && 12584 patchFlag & 64 /* PatchFlags.STABLE_FRAGMENT */ && 12585 dynamicChildren && 12586 // #2715 the previous fragment could've been a BAILed one as a result 12587 // of renderSlot() with no valid children 12588 n1.dynamicChildren) { 12589 // a stable fragment (template root or <template v-for>) doesn't need to 12590 // patch children order, but it may contain dynamicChildren. 12591 patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, isSVG, slotScopeIds); 12592 if (( true) && parentComponent && parentComponent.type.__hmrId) { 12593 traverseStaticChildren(n1, n2); 12594 } 12595 else if ( 12596 // #2080 if the stable fragment has a key, it's a <template v-for> that may 12597 // get moved around. Make sure all root level vnodes inherit el. 12598 // #2134 or if it's a component root, it may also get moved around 12599 // as the component is being moved. 12600 n2.key != null || 12601 (parentComponent && n2 === parentComponent.subTree)) { 12602 traverseStaticChildren(n1, n2, true /* shallow */); 12603 } 12604 } 12605 else { 12606 // keyed / unkeyed, or manual fragments. 12607 // for keyed & unkeyed, since they are compiler generated from v-for, 12608 // each child is guaranteed to be a block so the fragment will never 12609 // have dynamicChildren. 12610 patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12611 } 12612 } 12613 }; 12614 const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { 12615 n2.slotScopeIds = slotScopeIds; 12616 if (n1 == null) { 12617 if (n2.shapeFlag & 512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */) { 12618 parentComponent.ctx.activate(n2, container, anchor, isSVG, optimized); 12619 } 12620 else { 12621 mountComponent(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized); 12622 } 12623 } 12624 else { 12625 updateComponent(n1, n2, optimized); 12626 } 12627 }; 12628 const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => { 12629 const instance = (initialVNode.component = createComponentInstance(initialVNode, parentComponent, parentSuspense)); 12630 if (( true) && instance.type.__hmrId) { 12631 registerHMR(instance); 12632 } 12633 if ((true)) { 12634 pushWarningContext(initialVNode); 12635 startMeasure(instance, `mount`); 12636 } 12637 // inject renderer internals for keepAlive 12638 if (isKeepAlive(initialVNode)) { 12639 instance.ctx.renderer = internals; 12640 } 12641 // resolve props and slots for setup context 12642 { 12643 if ((true)) { 12644 startMeasure(instance, `init`); 12645 } 12646 setupComponent(instance); 12647 if ((true)) { 12648 endMeasure(instance, `init`); 12649 } 12650 } 12651 // setup() is async. This component relies on async logic to be resolved 12652 // before proceeding 12653 if (instance.asyncDep) { 12654 parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect); 12655 // Give it a placeholder if this is not hydration 12656 // TODO handle self-defined fallback 12657 if (!initialVNode.el) { 12658 const placeholder = (instance.subTree = createVNode(Comment)); 12659 processCommentNode(null, placeholder, container, anchor); 12660 } 12661 return; 12662 } 12663 setupRenderEffect(instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized); 12664 if ((true)) { 12665 popWarningContext(); 12666 endMeasure(instance, `mount`); 12667 } 12668 }; 12669 const updateComponent = (n1, n2, optimized) => { 12670 const instance = (n2.component = n1.component); 12671 if (shouldUpdateComponent(n1, n2, optimized)) { 12672 if (instance.asyncDep && 12673 !instance.asyncResolved) { 12674 // async & still pending - just update props and slots 12675 // since the component's reactive effect for render isn't set-up yet 12676 if ((true)) { 12677 pushWarningContext(n2); 12678 } 12679 updateComponentPreRender(instance, n2, optimized); 12680 if ((true)) { 12681 popWarningContext(); 12682 } 12683 return; 12684 } 12685 else { 12686 // normal update 12687 instance.next = n2; 12688 // in case the child component is also queued, remove it to avoid 12689 // double updating the same child component in the same flush. 12690 invalidateJob(instance.update); 12691 // instance.update is the reactive effect. 12692 instance.update(); 12693 } 12694 } 12695 else { 12696 // no update needed. just copy over properties 12697 n2.el = n1.el; 12698 instance.vnode = n2; 12699 } 12700 }; 12701 const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => { 12702 const componentUpdateFn = () => { 12703 if (!instance.isMounted) { 12704 let vnodeHook; 12705 const { el, props } = initialVNode; 12706 const { bm, m, parent } = instance; 12707 const isAsyncWrapperVNode = isAsyncWrapper(initialVNode); 12708 toggleRecurse(instance, false); 12709 // beforeMount hook 12710 if (bm) { 12711 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(bm); 12712 } 12713 // onVnodeBeforeMount 12714 if (!isAsyncWrapperVNode && 12715 (vnodeHook = props && props.onVnodeBeforeMount)) { 12716 invokeVNodeHook(vnodeHook, parent, initialVNode); 12717 } 12718 toggleRecurse(instance, true); 12719 if (el && hydrateNode) { 12720 // vnode has adopted host node - perform hydration instead of mount. 12721 const hydrateSubTree = () => { 12722 if ((true)) { 12723 startMeasure(instance, `render`); 12724 } 12725 instance.subTree = renderComponentRoot(instance); 12726 if ((true)) { 12727 endMeasure(instance, `render`); 12728 } 12729 if ((true)) { 12730 startMeasure(instance, `hydrate`); 12731 } 12732 hydrateNode(el, instance.subTree, instance, parentSuspense, null); 12733 if ((true)) { 12734 endMeasure(instance, `hydrate`); 12735 } 12736 }; 12737 if (isAsyncWrapperVNode) { 12738 initialVNode.type.__asyncLoader().then( 12739 // note: we are moving the render call into an async callback, 12740 // which means it won't track dependencies - but it's ok because 12741 // a server-rendered async wrapper is already in resolved state 12742 // and it will never need to change. 12743 () => !instance.isUnmounted && hydrateSubTree()); 12744 } 12745 else { 12746 hydrateSubTree(); 12747 } 12748 } 12749 else { 12750 if ((true)) { 12751 startMeasure(instance, `render`); 12752 } 12753 const subTree = (instance.subTree = renderComponentRoot(instance)); 12754 if ((true)) { 12755 endMeasure(instance, `render`); 12756 } 12757 if ((true)) { 12758 startMeasure(instance, `patch`); 12759 } 12760 patch(null, subTree, container, anchor, instance, parentSuspense, isSVG); 12761 if ((true)) { 12762 endMeasure(instance, `patch`); 12763 } 12764 initialVNode.el = subTree.el; 12765 } 12766 // mounted hook 12767 if (m) { 12768 queuePostRenderEffect(m, parentSuspense); 12769 } 12770 // onVnodeMounted 12771 if (!isAsyncWrapperVNode && 12772 (vnodeHook = props && props.onVnodeMounted)) { 12773 const scopedInitialVNode = initialVNode; 12774 queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode), parentSuspense); 12775 } 12776 // activated hook for keep-alive roots. 12777 // #1742 activated hook must be accessed after first render 12778 // since the hook may be injected by a child keep-alive 12779 if (initialVNode.shapeFlag & 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */ || 12780 (parent && 12781 isAsyncWrapper(parent.vnode) && 12782 parent.vnode.shapeFlag & 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */)) { 12783 instance.a && queuePostRenderEffect(instance.a, parentSuspense); 12784 } 12785 instance.isMounted = true; 12786 if (true) { 12787 devtoolsComponentAdded(instance); 12788 } 12789 // #2458: deference mount-only object parameters to prevent memleaks 12790 initialVNode = container = anchor = null; 12791 } 12792 else { 12793 // updateComponent 12794 // This is triggered by mutation of component's own state (next: null) 12795 // OR parent calling processComponent (next: VNode) 12796 let { next, bu, u, parent, vnode } = instance; 12797 let originNext = next; 12798 let vnodeHook; 12799 if ((true)) { 12800 pushWarningContext(next || instance.vnode); 12801 } 12802 // Disallow component effect recursion during pre-lifecycle hooks. 12803 toggleRecurse(instance, false); 12804 if (next) { 12805 next.el = vnode.el; 12806 updateComponentPreRender(instance, next, optimized); 12807 } 12808 else { 12809 next = vnode; 12810 } 12811 // beforeUpdate hook 12812 if (bu) { 12813 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(bu); 12814 } 12815 // onVnodeBeforeUpdate 12816 if ((vnodeHook = next.props && next.props.onVnodeBeforeUpdate)) { 12817 invokeVNodeHook(vnodeHook, parent, next, vnode); 12818 } 12819 toggleRecurse(instance, true); 12820 // render 12821 if ((true)) { 12822 startMeasure(instance, `render`); 12823 } 12824 const nextTree = renderComponentRoot(instance); 12825 if ((true)) { 12826 endMeasure(instance, `render`); 12827 } 12828 const prevTree = instance.subTree; 12829 instance.subTree = nextTree; 12830 if ((true)) { 12831 startMeasure(instance, `patch`); 12832 } 12833 patch(prevTree, nextTree, 12834 // parent may have changed if it's in a teleport 12835 hostParentNode(prevTree.el), 12836 // anchor may have changed if it's in a fragment 12837 getNextHostNode(prevTree), instance, parentSuspense, isSVG); 12838 if ((true)) { 12839 endMeasure(instance, `patch`); 12840 } 12841 next.el = nextTree.el; 12842 if (originNext === null) { 12843 // self-triggered update. In case of HOC, update parent component 12844 // vnode el. HOC is indicated by parent instance's subTree pointing 12845 // to child component's vnode 12846 updateHOCHostEl(instance, nextTree.el); 12847 } 12848 // updated hook 12849 if (u) { 12850 queuePostRenderEffect(u, parentSuspense); 12851 } 12852 // onVnodeUpdated 12853 if ((vnodeHook = next.props && next.props.onVnodeUpdated)) { 12854 queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, next, vnode), parentSuspense); 12855 } 12856 if (true) { 12857 devtoolsComponentUpdated(instance); 12858 } 12859 if ((true)) { 12860 popWarningContext(); 12861 } 12862 } 12863 }; 12864 // create reactive effect for rendering 12865 const effect = (instance.effect = new _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect(componentUpdateFn, () => queueJob(update), instance.scope // track it in component's effect scope 12866 )); 12867 const update = (instance.update = () => effect.run()); 12868 update.id = instance.uid; 12869 // allowRecurse 12870 // #1801, #2043 component render effects should allow recursive updates 12871 toggleRecurse(instance, true); 12872 if ((true)) { 12873 effect.onTrack = instance.rtc 12874 ? e => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance.rtc, e) 12875 : void 0; 12876 effect.onTrigger = instance.rtg 12877 ? e => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance.rtg, e) 12878 : void 0; 12879 update.ownerInstance = instance; 12880 } 12881 update(); 12882 }; 12883 const updateComponentPreRender = (instance, nextVNode, optimized) => { 12884 nextVNode.component = instance; 12885 const prevProps = instance.vnode.props; 12886 instance.vnode = nextVNode; 12887 instance.next = null; 12888 updateProps(instance, nextVNode.props, prevProps, optimized); 12889 updateSlots(instance, nextVNode.children, optimized); 12890 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 12891 // props update may have triggered pre-flush watchers. 12892 // flush them before the render update. 12893 flushPreFlushCbs(); 12894 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 12895 }; 12896 const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized = false) => { 12897 const c1 = n1 && n1.children; 12898 const prevShapeFlag = n1 ? n1.shapeFlag : 0; 12899 const c2 = n2.children; 12900 const { patchFlag, shapeFlag } = n2; 12901 // fast path 12902 if (patchFlag > 0) { 12903 if (patchFlag & 128 /* PatchFlags.KEYED_FRAGMENT */) { 12904 // this could be either fully-keyed or mixed (some keyed some not) 12905 // presence of patchFlag means children are guaranteed to be arrays 12906 patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12907 return; 12908 } 12909 else if (patchFlag & 256 /* PatchFlags.UNKEYED_FRAGMENT */) { 12910 // unkeyed 12911 patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12912 return; 12913 } 12914 } 12915 // children has 3 possibilities: text, array or no children. 12916 if (shapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) { 12917 // text children fast path 12918 if (prevShapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) { 12919 unmountChildren(c1, parentComponent, parentSuspense); 12920 } 12921 if (c2 !== c1) { 12922 hostSetElementText(container, c2); 12923 } 12924 } 12925 else { 12926 if (prevShapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) { 12927 // prev children was array 12928 if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) { 12929 // two arrays, cannot assume anything, do full diff 12930 patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12931 } 12932 else { 12933 // no new children, just unmount old 12934 unmountChildren(c1, parentComponent, parentSuspense, true); 12935 } 12936 } 12937 else { 12938 // prev children was text OR null 12939 // new children is array OR null 12940 if (prevShapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) { 12941 hostSetElementText(container, ''); 12942 } 12943 // mount new if array 12944 if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) { 12945 mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12946 } 12947 } 12948 } 12949 }; 12950 const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { 12951 c1 = c1 || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR; 12952 c2 = c2 || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR; 12953 const oldLength = c1.length; 12954 const newLength = c2.length; 12955 const commonLength = Math.min(oldLength, newLength); 12956 let i; 12957 for (i = 0; i < commonLength; i++) { 12958 const nextChild = (c2[i] = optimized 12959 ? cloneIfMounted(c2[i]) 12960 : normalizeVNode(c2[i])); 12961 patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12962 } 12963 if (oldLength > newLength) { 12964 // remove old 12965 unmountChildren(c1, parentComponent, parentSuspense, true, false, commonLength); 12966 } 12967 else { 12968 // mount new 12969 mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, commonLength); 12970 } 12971 }; 12972 // can be all-keyed or mixed 12973 const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { 12974 let i = 0; 12975 const l2 = c2.length; 12976 let e1 = c1.length - 1; // prev ending index 12977 let e2 = l2 - 1; // next ending index 12978 // 1. sync from start 12979 // (a b) c 12980 // (a b) d e 12981 while (i <= e1 && i <= e2) { 12982 const n1 = c1[i]; 12983 const n2 = (c2[i] = optimized 12984 ? cloneIfMounted(c2[i]) 12985 : normalizeVNode(c2[i])); 12986 if (isSameVNodeType(n1, n2)) { 12987 patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 12988 } 12989 else { 12990 break; 12991 } 12992 i++; 12993 } 12994 // 2. sync from end 12995 // a (b c) 12996 // d e (b c) 12997 while (i <= e1 && i <= e2) { 12998 const n1 = c1[e1]; 12999 const n2 = (c2[e2] = optimized 13000 ? cloneIfMounted(c2[e2]) 13001 : normalizeVNode(c2[e2])); 13002 if (isSameVNodeType(n1, n2)) { 13003 patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 13004 } 13005 else { 13006 break; 13007 } 13008 e1--; 13009 e2--; 13010 } 13011 // 3. common sequence + mount 13012 // (a b) 13013 // (a b) c 13014 // i = 2, e1 = 1, e2 = 2 13015 // (a b) 13016 // c (a b) 13017 // i = 0, e1 = -1, e2 = 0 13018 if (i > e1) { 13019 if (i <= e2) { 13020 const nextPos = e2 + 1; 13021 const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor; 13022 while (i <= e2) { 13023 patch(null, (c2[i] = optimized 13024 ? cloneIfMounted(c2[i]) 13025 : normalizeVNode(c2[i])), container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 13026 i++; 13027 } 13028 } 13029 } 13030 // 4. common sequence + unmount 13031 // (a b) c 13032 // (a b) 13033 // i = 2, e1 = 2, e2 = 1 13034 // a (b c) 13035 // (b c) 13036 // i = 0, e1 = 0, e2 = -1 13037 else if (i > e2) { 13038 while (i <= e1) { 13039 unmount(c1[i], parentComponent, parentSuspense, true); 13040 i++; 13041 } 13042 } 13043 // 5. unknown sequence 13044 // [i ... e1 + 1]: a b [c d e] f g 13045 // [i ... e2 + 1]: a b [e d c h] f g 13046 // i = 2, e1 = 4, e2 = 5 13047 else { 13048 const s1 = i; // prev starting index 13049 const s2 = i; // next starting index 13050 // 5.1 build key:index map for newChildren 13051 const keyToNewIndexMap = new Map(); 13052 for (i = s2; i <= e2; i++) { 13053 const nextChild = (c2[i] = optimized 13054 ? cloneIfMounted(c2[i]) 13055 : normalizeVNode(c2[i])); 13056 if (nextChild.key != null) { 13057 if (( true) && keyToNewIndexMap.has(nextChild.key)) { 13058 warn(`Duplicate keys found during update:`, JSON.stringify(nextChild.key), `Make sure keys are unique.`); 13059 } 13060 keyToNewIndexMap.set(nextChild.key, i); 13061 } 13062 } 13063 // 5.2 loop through old children left to be patched and try to patch 13064 // matching nodes & remove nodes that are no longer present 13065 let j; 13066 let patched = 0; 13067 const toBePatched = e2 - s2 + 1; 13068 let moved = false; 13069 // used to track whether any node has moved 13070 let maxNewIndexSoFar = 0; 13071 // works as Map<newIndex, oldIndex> 13072 // Note that oldIndex is offset by +1 13073 // and oldIndex = 0 is a special value indicating the new node has 13074 // no corresponding old node. 13075 // used for determining longest stable subsequence 13076 const newIndexToOldIndexMap = new Array(toBePatched); 13077 for (i = 0; i < toBePatched; i++) 13078 newIndexToOldIndexMap[i] = 0; 13079 for (i = s1; i <= e1; i++) { 13080 const prevChild = c1[i]; 13081 if (patched >= toBePatched) { 13082 // all new children have been patched so this can only be a removal 13083 unmount(prevChild, parentComponent, parentSuspense, true); 13084 continue; 13085 } 13086 let newIndex; 13087 if (prevChild.key != null) { 13088 newIndex = keyToNewIndexMap.get(prevChild.key); 13089 } 13090 else { 13091 // key-less node, try to locate a key-less node of the same type 13092 for (j = s2; j <= e2; j++) { 13093 if (newIndexToOldIndexMap[j - s2] === 0 && 13094 isSameVNodeType(prevChild, c2[j])) { 13095 newIndex = j; 13096 break; 13097 } 13098 } 13099 } 13100 if (newIndex === undefined) { 13101 unmount(prevChild, parentComponent, parentSuspense, true); 13102 } 13103 else { 13104 newIndexToOldIndexMap[newIndex - s2] = i + 1; 13105 if (newIndex >= maxNewIndexSoFar) { 13106 maxNewIndexSoFar = newIndex; 13107 } 13108 else { 13109 moved = true; 13110 } 13111 patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 13112 patched++; 13113 } 13114 } 13115 // 5.3 move and mount 13116 // generate longest stable subsequence only when nodes have moved 13117 const increasingNewIndexSequence = moved 13118 ? getSequence(newIndexToOldIndexMap) 13119 : _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR; 13120 j = increasingNewIndexSequence.length - 1; 13121 // looping backwards so that we can use last patched node as anchor 13122 for (i = toBePatched - 1; i >= 0; i--) { 13123 const nextIndex = s2 + i; 13124 const nextChild = c2[nextIndex]; 13125 const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor; 13126 if (newIndexToOldIndexMap[i] === 0) { 13127 // mount new 13128 patch(null, nextChild, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 13129 } 13130 else if (moved) { 13131 // move if: 13132 // There is no stable subsequence (e.g. a reverse) 13133 // OR current node is not among the stable sequence 13134 if (j < 0 || i !== increasingNewIndexSequence[j]) { 13135 move(nextChild, container, anchor, 2 /* MoveType.REORDER */); 13136 } 13137 else { 13138 j--; 13139 } 13140 } 13141 } 13142 } 13143 }; 13144 const move = (vnode, container, anchor, moveType, parentSuspense = null) => { 13145 const { el, type, transition, children, shapeFlag } = vnode; 13146 if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) { 13147 move(vnode.component.subTree, container, anchor, moveType); 13148 return; 13149 } 13150 if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) { 13151 vnode.suspense.move(container, anchor, moveType); 13152 return; 13153 } 13154 if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) { 13155 type.move(vnode, container, anchor, internals); 13156 return; 13157 } 13158 if (type === Fragment) { 13159 hostInsert(el, container, anchor); 13160 for (let i = 0; i < children.length; i++) { 13161 move(children[i], container, anchor, moveType); 13162 } 13163 hostInsert(vnode.anchor, container, anchor); 13164 return; 13165 } 13166 if (type === Static) { 13167 moveStaticNode(vnode, container, anchor); 13168 return; 13169 } 13170 // single nodes 13171 const needTransition = moveType !== 2 /* MoveType.REORDER */ && 13172 shapeFlag & 1 /* ShapeFlags.ELEMENT */ && 13173 transition; 13174 if (needTransition) { 13175 if (moveType === 0 /* MoveType.ENTER */) { 13176 transition.beforeEnter(el); 13177 hostInsert(el, container, anchor); 13178 queuePostRenderEffect(() => transition.enter(el), parentSuspense); 13179 } 13180 else { 13181 const { leave, delayLeave, afterLeave } = transition; 13182 const remove = () => hostInsert(el, container, anchor); 13183 const performLeave = () => { 13184 leave(el, () => { 13185 remove(); 13186 afterLeave && afterLeave(); 13187 }); 13188 }; 13189 if (delayLeave) { 13190 delayLeave(el, remove, performLeave); 13191 } 13192 else { 13193 performLeave(); 13194 } 13195 } 13196 } 13197 else { 13198 hostInsert(el, container, anchor); 13199 } 13200 }; 13201 const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => { 13202 const { type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs } = vnode; 13203 // unset ref 13204 if (ref != null) { 13205 setRef(ref, null, parentSuspense, vnode, true); 13206 } 13207 if (shapeFlag & 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */) { 13208 parentComponent.ctx.deactivate(vnode); 13209 return; 13210 } 13211 const shouldInvokeDirs = shapeFlag & 1 /* ShapeFlags.ELEMENT */ && dirs; 13212 const shouldInvokeVnodeHook = !isAsyncWrapper(vnode); 13213 let vnodeHook; 13214 if (shouldInvokeVnodeHook && 13215 (vnodeHook = props && props.onVnodeBeforeUnmount)) { 13216 invokeVNodeHook(vnodeHook, parentComponent, vnode); 13217 } 13218 if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) { 13219 unmountComponent(vnode.component, parentSuspense, doRemove); 13220 } 13221 else { 13222 if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) { 13223 vnode.suspense.unmount(parentSuspense, doRemove); 13224 return; 13225 } 13226 if (shouldInvokeDirs) { 13227 invokeDirectiveHook(vnode, null, parentComponent, 'beforeUnmount'); 13228 } 13229 if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) { 13230 vnode.type.remove(vnode, parentComponent, parentSuspense, optimized, internals, doRemove); 13231 } 13232 else if (dynamicChildren && 13233 // #1153: fast path should not be taken for non-stable (v-for) fragments 13234 (type !== Fragment || 13235 (patchFlag > 0 && patchFlag & 64 /* PatchFlags.STABLE_FRAGMENT */))) { 13236 // fast path for block nodes: only need to unmount dynamic children. 13237 unmountChildren(dynamicChildren, parentComponent, parentSuspense, false, true); 13238 } 13239 else if ((type === Fragment && 13240 patchFlag & 13241 (128 /* PatchFlags.KEYED_FRAGMENT */ | 256 /* PatchFlags.UNKEYED_FRAGMENT */)) || 13242 (!optimized && shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */)) { 13243 unmountChildren(children, parentComponent, parentSuspense); 13244 } 13245 if (doRemove) { 13246 remove(vnode); 13247 } 13248 } 13249 if ((shouldInvokeVnodeHook && 13250 (vnodeHook = props && props.onVnodeUnmounted)) || 13251 shouldInvokeDirs) { 13252 queuePostRenderEffect(() => { 13253 vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode); 13254 shouldInvokeDirs && 13255 invokeDirectiveHook(vnode, null, parentComponent, 'unmounted'); 13256 }, parentSuspense); 13257 } 13258 }; 13259 const remove = vnode => { 13260 const { type, el, anchor, transition } = vnode; 13261 if (type === Fragment) { 13262 if (( true) && 13263 vnode.patchFlag > 0 && 13264 vnode.patchFlag & 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */ && 13265 transition && 13266 !transition.persisted) { 13267 vnode.children.forEach(child => { 13268 if (child.type === Comment) { 13269 hostRemove(child.el); 13270 } 13271 else { 13272 remove(child); 13273 } 13274 }); 13275 } 13276 else { 13277 removeFragment(el, anchor); 13278 } 13279 return; 13280 } 13281 if (type === Static) { 13282 removeStaticNode(vnode); 13283 return; 13284 } 13285 const performRemove = () => { 13286 hostRemove(el); 13287 if (transition && !transition.persisted && transition.afterLeave) { 13288 transition.afterLeave(); 13289 } 13290 }; 13291 if (vnode.shapeFlag & 1 /* ShapeFlags.ELEMENT */ && 13292 transition && 13293 !transition.persisted) { 13294 const { leave, delayLeave } = transition; 13295 const performLeave = () => leave(el, performRemove); 13296 if (delayLeave) { 13297 delayLeave(vnode.el, performRemove, performLeave); 13298 } 13299 else { 13300 performLeave(); 13301 } 13302 } 13303 else { 13304 performRemove(); 13305 } 13306 }; 13307 const removeFragment = (cur, end) => { 13308 // For fragments, directly remove all contained DOM nodes. 13309 // (fragment child nodes cannot have transition) 13310 let next; 13311 while (cur !== end) { 13312 next = hostNextSibling(cur); 13313 hostRemove(cur); 13314 cur = next; 13315 } 13316 hostRemove(end); 13317 }; 13318 const unmountComponent = (instance, parentSuspense, doRemove) => { 13319 if (( true) && instance.type.__hmrId) { 13320 unregisterHMR(instance); 13321 } 13322 const { bum, scope, update, subTree, um } = instance; 13323 // beforeUnmount hook 13324 if (bum) { 13325 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(bum); 13326 } 13327 // stop effects in component scope 13328 scope.stop(); 13329 // update may be null if a component is unmounted before its async 13330 // setup has resolved. 13331 if (update) { 13332 // so that scheduler will no longer invoke it 13333 update.active = false; 13334 unmount(subTree, instance, parentSuspense, doRemove); 13335 } 13336 // unmounted hook 13337 if (um) { 13338 queuePostRenderEffect(um, parentSuspense); 13339 } 13340 queuePostRenderEffect(() => { 13341 instance.isUnmounted = true; 13342 }, parentSuspense); 13343 // A component with async dep inside a pending suspense is unmounted before 13344 // its async dep resolves. This should remove the dep from the suspense, and 13345 // cause the suspense to resolve immediately if that was the last dep. 13346 if (parentSuspense && 13347 parentSuspense.pendingBranch && 13348 !parentSuspense.isUnmounted && 13349 instance.asyncDep && 13350 !instance.asyncResolved && 13351 instance.suspenseId === parentSuspense.pendingId) { 13352 parentSuspense.deps--; 13353 if (parentSuspense.deps === 0) { 13354 parentSuspense.resolve(); 13355 } 13356 } 13357 if (true) { 13358 devtoolsComponentRemoved(instance); 13359 } 13360 }; 13361 const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => { 13362 for (let i = start; i < children.length; i++) { 13363 unmount(children[i], parentComponent, parentSuspense, doRemove, optimized); 13364 } 13365 }; 13366 const getNextHostNode = vnode => { 13367 if (vnode.shapeFlag & 6 /* ShapeFlags.COMPONENT */) { 13368 return getNextHostNode(vnode.component.subTree); 13369 } 13370 if (vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */) { 13371 return vnode.suspense.next(); 13372 } 13373 return hostNextSibling((vnode.anchor || vnode.el)); 13374 }; 13375 const render = (vnode, container, isSVG) => { 13376 if (vnode == null) { 13377 if (container._vnode) { 13378 unmount(container._vnode, null, null, true); 13379 } 13380 } 13381 else { 13382 patch(container._vnode || null, vnode, container, null, null, null, isSVG); 13383 } 13384 flushPreFlushCbs(); 13385 flushPostFlushCbs(); 13386 container._vnode = vnode; 13387 }; 13388 const internals = { 13389 p: patch, 13390 um: unmount, 13391 m: move, 13392 r: remove, 13393 mt: mountComponent, 13394 mc: mountChildren, 13395 pc: patchChildren, 13396 pbc: patchBlockChildren, 13397 n: getNextHostNode, 13398 o: options 13399 }; 13400 let hydrate; 13401 let hydrateNode; 13402 if (createHydrationFns) { 13403 [hydrate, hydrateNode] = createHydrationFns(internals); 13404 } 13405 return { 13406 render, 13407 hydrate, 13408 createApp: createAppAPI(render, hydrate) 13409 }; 13410} 13411function toggleRecurse({ effect, update }, allowed) { 13412 effect.allowRecurse = update.allowRecurse = allowed; 13413} 13414/** 13415 * #1156 13416 * When a component is HMR-enabled, we need to make sure that all static nodes 13417 * inside a block also inherit the DOM element from the previous tree so that 13418 * HMR updates (which are full updates) can retrieve the element for patching. 13419 * 13420 * #2080 13421 * Inside keyed `template` fragment static children, if a fragment is moved, 13422 * the children will always be moved. Therefore, in order to ensure correct move 13423 * position, el should be inherited from previous nodes. 13424 */ 13425function traverseStaticChildren(n1, n2, shallow = false) { 13426 const ch1 = n1.children; 13427 const ch2 = n2.children; 13428 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(ch1) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(ch2)) { 13429 for (let i = 0; i < ch1.length; i++) { 13430 // this is only called in the optimized path so array children are 13431 // guaranteed to be vnodes 13432 const c1 = ch1[i]; 13433 let c2 = ch2[i]; 13434 if (c2.shapeFlag & 1 /* ShapeFlags.ELEMENT */ && !c2.dynamicChildren) { 13435 if (c2.patchFlag <= 0 || c2.patchFlag === 32 /* PatchFlags.HYDRATE_EVENTS */) { 13436 c2 = ch2[i] = cloneIfMounted(ch2[i]); 13437 c2.el = c1.el; 13438 } 13439 if (!shallow) 13440 traverseStaticChildren(c1, c2); 13441 } 13442 // #6852 also inherit for text nodes 13443 if (c2.type === Text) { 13444 c2.el = c1.el; 13445 } 13446 // also inherit for comment nodes, but not placeholders (e.g. v-if which 13447 // would have received .el during block patch) 13448 if (( true) && c2.type === Comment && !c2.el) { 13449 c2.el = c1.el; 13450 } 13451 } 13452 } 13453} 13454// https://en.wikipedia.org/wiki/Longest_increasing_subsequence 13455function getSequence(arr) { 13456 const p = arr.slice(); 13457 const result = [0]; 13458 let i, j, u, v, c; 13459 const len = arr.length; 13460 for (i = 0; i < len; i++) { 13461 const arrI = arr[i]; 13462 if (arrI !== 0) { 13463 j = result[result.length - 1]; 13464 if (arr[j] < arrI) { 13465 p[i] = j; 13466 result.push(i); 13467 continue; 13468 } 13469 u = 0; 13470 v = result.length - 1; 13471 while (u < v) { 13472 c = (u + v) >> 1; 13473 if (arr[result[c]] < arrI) { 13474 u = c + 1; 13475 } 13476 else { 13477 v = c; 13478 } 13479 } 13480 if (arrI < arr[result[u]]) { 13481 if (u > 0) { 13482 p[i] = result[u - 1]; 13483 } 13484 result[u] = i; 13485 } 13486 } 13487 } 13488 u = result.length; 13489 v = result[u - 1]; 13490 while (u-- > 0) { 13491 result[u] = v; 13492 v = p[v]; 13493 } 13494 return result; 13495} 13496 13497const isTeleport = (type) => type.__isTeleport; 13498const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === ''); 13499const isTargetSVG = (target) => typeof SVGElement !== 'undefined' && target instanceof SVGElement; 13500const resolveTarget = (props, select) => { 13501 const targetSelector = props && props.to; 13502 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(targetSelector)) { 13503 if (!select) { 13504 ( true) && 13505 warn(`Current renderer does not support string target for Teleports. ` + 13506 `(missing querySelector renderer option)`); 13507 return null; 13508 } 13509 else { 13510 const target = select(targetSelector); 13511 if (!target) { 13512 ( true) && 13513 warn(`Failed to locate Teleport target with selector "${targetSelector}". ` + 13514 `Note the target element must exist before the component is mounted - ` + 13515 `i.e. the target cannot be rendered by the component itself, and ` + 13516 `ideally should be outside of the entire Vue component tree.`); 13517 } 13518 return target; 13519 } 13520 } 13521 else { 13522 if (( true) && !targetSelector && !isTeleportDisabled(props)) { 13523 warn(`Invalid Teleport target: ${targetSelector}`); 13524 } 13525 return targetSelector; 13526 } 13527}; 13528const TeleportImpl = { 13529 __isTeleport: true, 13530 process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals) { 13531 const { mc: mountChildren, pc: patchChildren, pbc: patchBlockChildren, o: { insert, querySelector, createText, createComment } } = internals; 13532 const disabled = isTeleportDisabled(n2.props); 13533 let { shapeFlag, children, dynamicChildren } = n2; 13534 // #3302 13535 // HMR updated, force full diff 13536 if (( true) && isHmrUpdating) { 13537 optimized = false; 13538 dynamicChildren = null; 13539 } 13540 if (n1 == null) { 13541 // insert anchors in the main view 13542 const placeholder = (n2.el = ( true) 13543 ? createComment('teleport start') 13544 : 0); 13545 const mainAnchor = (n2.anchor = ( true) 13546 ? createComment('teleport end') 13547 : 0); 13548 insert(placeholder, container, anchor); 13549 insert(mainAnchor, container, anchor); 13550 const target = (n2.target = resolveTarget(n2.props, querySelector)); 13551 const targetAnchor = (n2.targetAnchor = createText('')); 13552 if (target) { 13553 insert(targetAnchor, target); 13554 // #2652 we could be teleporting from a non-SVG tree into an SVG tree 13555 isSVG = isSVG || isTargetSVG(target); 13556 } 13557 else if (( true) && !disabled) { 13558 warn('Invalid Teleport target on mount:', target, `(${typeof target})`); 13559 } 13560 const mount = (container, anchor) => { 13561 // Teleport *always* has Array children. This is enforced in both the 13562 // compiler and vnode children normalization. 13563 if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) { 13564 mountChildren(children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); 13565 } 13566 }; 13567 if (disabled) { 13568 mount(container, mainAnchor); 13569 } 13570 else if (target) { 13571 mount(target, targetAnchor); 13572 } 13573 } 13574 else { 13575 // update content 13576 n2.el = n1.el; 13577 const mainAnchor = (n2.anchor = n1.anchor); 13578 const target = (n2.target = n1.target); 13579 const targetAnchor = (n2.targetAnchor = n1.targetAnchor); 13580 const wasDisabled = isTeleportDisabled(n1.props); 13581 const currentContainer = wasDisabled ? container : target; 13582 const currentAnchor = wasDisabled ? mainAnchor : targetAnchor; 13583 isSVG = isSVG || isTargetSVG(target); 13584 if (dynamicChildren) { 13585 // fast path when the teleport happens to be a block root 13586 patchBlockChildren(n1.dynamicChildren, dynamicChildren, currentContainer, parentComponent, parentSuspense, isSVG, slotScopeIds); 13587 // even in block tree mode we need to make sure all root-level nodes 13588 // in the teleport inherit previous DOM references so that they can 13589 // be moved in future patches. 13590 traverseStaticChildren(n1, n2, true); 13591 } 13592 else if (!optimized) { 13593 patchChildren(n1, n2, currentContainer, currentAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, false); 13594 } 13595 if (disabled) { 13596 if (!wasDisabled) { 13597 // enabled -> disabled 13598 // move into main container 13599 moveTeleport(n2, container, mainAnchor, internals, 1 /* TeleportMoveTypes.TOGGLE */); 13600 } 13601 } 13602 else { 13603 // target changed 13604 if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) { 13605 const nextTarget = (n2.target = resolveTarget(n2.props, querySelector)); 13606 if (nextTarget) { 13607 moveTeleport(n2, nextTarget, null, internals, 0 /* TeleportMoveTypes.TARGET_CHANGE */); 13608 } 13609 else if ((true)) { 13610 warn('Invalid Teleport target on update:', target, `(${typeof target})`); 13611 } 13612 } 13613 else if (wasDisabled) { 13614 // disabled -> enabled 13615 // move into teleport target 13616 moveTeleport(n2, target, targetAnchor, internals, 1 /* TeleportMoveTypes.TOGGLE */); 13617 } 13618 } 13619 } 13620 updateCssVars(n2); 13621 }, 13622 remove(vnode, parentComponent, parentSuspense, optimized, { um: unmount, o: { remove: hostRemove } }, doRemove) { 13623 const { shapeFlag, children, anchor, targetAnchor, target, props } = vnode; 13624 if (target) { 13625 hostRemove(targetAnchor); 13626 } 13627 // an unmounted teleport should always remove its children if not disabled 13628 if (doRemove || !isTeleportDisabled(props)) { 13629 hostRemove(anchor); 13630 if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) { 13631 for (let i = 0; i < children.length; i++) { 13632 const child = children[i]; 13633 unmount(child, parentComponent, parentSuspense, true, !!child.dynamicChildren); 13634 } 13635 } 13636 } 13637 }, 13638 move: moveTeleport, 13639 hydrate: hydrateTeleport 13640}; 13641function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2 /* TeleportMoveTypes.REORDER */) { 13642 // move target anchor if this is a target change. 13643 if (moveType === 0 /* TeleportMoveTypes.TARGET_CHANGE */) { 13644 insert(vnode.targetAnchor, container, parentAnchor); 13645 } 13646 const { el, anchor, shapeFlag, children, props } = vnode; 13647 const isReorder = moveType === 2 /* TeleportMoveTypes.REORDER */; 13648 // move main view anchor if this is a re-order. 13649 if (isReorder) { 13650 insert(el, container, parentAnchor); 13651 } 13652 // if this is a re-order and teleport is enabled (content is in target) 13653 // do not move children. So the opposite is: only move children if this 13654 // is not a reorder, or the teleport is disabled 13655 if (!isReorder || isTeleportDisabled(props)) { 13656 // Teleport has either Array children or no children. 13657 if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) { 13658 for (let i = 0; i < children.length; i++) { 13659 move(children[i], container, parentAnchor, 2 /* MoveType.REORDER */); 13660 } 13661 } 13662 } 13663 // move main view anchor if this is a re-order. 13664 if (isReorder) { 13665 insert(anchor, container, parentAnchor); 13666 } 13667} 13668function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, { o: { nextSibling, parentNode, querySelector } }, hydrateChildren) { 13669 const target = (vnode.target = resolveTarget(vnode.props, querySelector)); 13670 if (target) { 13671 // if multiple teleports rendered to the same target element, we need to 13672 // pick up from where the last teleport finished instead of the first node 13673 const targetNode = target._lpa || target.firstChild; 13674 if (vnode.shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) { 13675 if (isTeleportDisabled(vnode.props)) { 13676 vnode.anchor = hydrateChildren(nextSibling(node), vnode, parentNode(node), parentComponent, parentSuspense, slotScopeIds, optimized); 13677 vnode.targetAnchor = targetNode; 13678 } 13679 else { 13680 vnode.anchor = nextSibling(node); 13681 // lookahead until we find the target anchor 13682 // we cannot rely on return value of hydrateChildren() because there 13683 // could be nested teleports 13684 let targetAnchor = targetNode; 13685 while (targetAnchor) { 13686 targetAnchor = nextSibling(targetAnchor); 13687 if (targetAnchor && 13688 targetAnchor.nodeType === 8 && 13689 targetAnchor.data === 'teleport anchor') { 13690 vnode.targetAnchor = targetAnchor; 13691 target._lpa = 13692 vnode.targetAnchor && nextSibling(vnode.targetAnchor); 13693 break; 13694 } 13695 } 13696 hydrateChildren(targetNode, vnode, target, parentComponent, parentSuspense, slotScopeIds, optimized); 13697 } 13698 } 13699 updateCssVars(vnode); 13700 } 13701 return vnode.anchor && nextSibling(vnode.anchor); 13702} 13703// Force-casted public typing for h and TSX props inference 13704const Teleport = TeleportImpl; 13705function updateCssVars(vnode) { 13706 // presence of .ut method indicates owner component uses css vars. 13707 // code path here can assume browser environment. 13708 const ctx = vnode.ctx; 13709 if (ctx && ctx.ut) { 13710 let node = vnode.children[0].el; 13711 while (node !== vnode.targetAnchor) { 13712 if (node.nodeType === 1) 13713 node.setAttribute('data-v-owner', ctx.uid); 13714 node = node.nextSibling; 13715 } 13716 ctx.ut(); 13717 } 13718} 13719 13720const Fragment = Symbol(( true) ? 'Fragment' : 0); 13721const Text = Symbol(( true) ? 'Text' : 0); 13722const Comment = Symbol(( true) ? 'Comment' : 0); 13723const Static = Symbol(( true) ? 'Static' : 0); 13724// Since v-if and v-for are the two possible ways node structure can dynamically 13725// change, once we consider v-if branches and each v-for fragment a block, we 13726// can divide a template into nested blocks, and within each block the node 13727// structure would be stable. This allows us to skip most children diffing 13728// and only worry about the dynamic nodes (indicated by patch flags). 13729const blockStack = []; 13730let currentBlock = null; 13731/** 13732 * Open a block. 13733 * This must be called before `createBlock`. It cannot be part of `createBlock` 13734 * because the children of the block are evaluated before `createBlock` itself 13735 * is called. The generated code typically looks like this: 13736 * 13737 * ```js 13738 * function render() { 13739 * return (openBlock(),createBlock('div', null, [...])) 13740 * } 13741 * ``` 13742 * disableTracking is true when creating a v-for fragment block, since a v-for 13743 * fragment always diffs its children. 13744 * 13745 * @private 13746 */ 13747function openBlock(disableTracking = false) { 13748 blockStack.push((currentBlock = disableTracking ? null : [])); 13749} 13750function closeBlock() { 13751 blockStack.pop(); 13752 currentBlock = blockStack[blockStack.length - 1] || null; 13753} 13754// Whether we should be tracking dynamic child nodes inside a block. 13755// Only tracks when this value is > 0 13756// We are not using a simple boolean because this value may need to be 13757// incremented/decremented by nested usage of v-once (see below) 13758let isBlockTreeEnabled = 1; 13759/** 13760 * Block tracking sometimes needs to be disabled, for example during the 13761 * creation of a tree that needs to be cached by v-once. The compiler generates 13762 * code like this: 13763 * 13764 * ``` js 13765 * _cache[1] || ( 13766 * setBlockTracking(-1), 13767 * _cache[1] = createVNode(...), 13768 * setBlockTracking(1), 13769 * _cache[1] 13770 * ) 13771 * ``` 13772 * 13773 * @private 13774 */ 13775function setBlockTracking(value) { 13776 isBlockTreeEnabled += value; 13777} 13778function setupBlock(vnode) { 13779 // save current block children on the block vnode 13780 vnode.dynamicChildren = 13781 isBlockTreeEnabled > 0 ? currentBlock || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR : null; 13782 // close block 13783 closeBlock(); 13784 // a block is always going to be patched, so track it as a child of its 13785 // parent block 13786 if (isBlockTreeEnabled > 0 && currentBlock) { 13787 currentBlock.push(vnode); 13788 } 13789 return vnode; 13790} 13791/** 13792 * @private 13793 */ 13794function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) { 13795 return setupBlock(createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, true /* isBlock */)); 13796} 13797/** 13798 * Create a block root vnode. Takes the same exact arguments as `createVNode`. 13799 * A block root keeps track of dynamic nodes within the block in the 13800 * `dynamicChildren` array. 13801 * 13802 * @private 13803 */ 13804function createBlock(type, props, children, patchFlag, dynamicProps) { 13805 return setupBlock(createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */)); 13806} 13807function isVNode(value) { 13808 return value ? value.__v_isVNode === true : false; 13809} 13810function isSameVNodeType(n1, n2) { 13811 if (( true) && 13812 n2.shapeFlag & 6 /* ShapeFlags.COMPONENT */ && 13813 hmrDirtyComponents.has(n2.type)) { 13814 // #7042, ensure the vnode being unmounted during HMR 13815 // bitwise operations to remove keep alive flags 13816 n1.shapeFlag &= ~256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */; 13817 n2.shapeFlag &= ~512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */; 13818 // HMR only: if the component has been hot-updated, force a reload. 13819 return false; 13820 } 13821 return n1.type === n2.type && n1.key === n2.key; 13822} 13823let vnodeArgsTransformer; 13824/** 13825 * Internal API for registering an arguments transform for createVNode 13826 * used for creating stubs in the test-utils 13827 * It is *internal* but needs to be exposed for test-utils to pick up proper 13828 * typings 13829 */ 13830function transformVNodeArgs(transformer) { 13831 vnodeArgsTransformer = transformer; 13832} 13833const createVNodeWithArgsTransform = (...args) => { 13834 return _createVNode(...(vnodeArgsTransformer 13835 ? vnodeArgsTransformer(args, currentRenderingInstance) 13836 : args)); 13837}; 13838const InternalObjectKey = `__vInternal`; 13839const normalizeKey = ({ key }) => key != null ? key : null; 13840const normalizeRef = ({ ref, ref_key, ref_for }) => { 13841 return (ref != null 13842 ? (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) 13843 ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } 13844 : ref 13845 : null); 13846}; 13847function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1 /* ShapeFlags.ELEMENT */, isBlockNode = false, needFullChildrenNormalization = false) { 13848 const vnode = { 13849 __v_isVNode: true, 13850 __v_skip: true, 13851 type, 13852 props, 13853 key: props && normalizeKey(props), 13854 ref: props && normalizeRef(props), 13855 scopeId: currentScopeId, 13856 slotScopeIds: null, 13857 children, 13858 component: null, 13859 suspense: null, 13860 ssContent: null, 13861 ssFallback: null, 13862 dirs: null, 13863 transition: null, 13864 el: null, 13865 anchor: null, 13866 target: null, 13867 targetAnchor: null, 13868 staticCount: 0, 13869 shapeFlag, 13870 patchFlag, 13871 dynamicProps, 13872 dynamicChildren: null, 13873 appContext: null, 13874 ctx: currentRenderingInstance 13875 }; 13876 if (needFullChildrenNormalization) { 13877 normalizeChildren(vnode, children); 13878 // normalize suspense children 13879 if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) { 13880 type.normalize(vnode); 13881 } 13882 } 13883 else if (children) { 13884 // compiled element vnode - if children is passed, only possible types are 13885 // string or Array. 13886 vnode.shapeFlag |= (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(children) 13887 ? 8 /* ShapeFlags.TEXT_CHILDREN */ 13888 : 16 /* ShapeFlags.ARRAY_CHILDREN */; 13889 } 13890 // validate key 13891 if (( true) && vnode.key !== vnode.key) { 13892 warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type); 13893 } 13894 // track vnode for block tree 13895 if (isBlockTreeEnabled > 0 && 13896 // avoid a block node from tracking itself 13897 !isBlockNode && 13898 // has current parent block 13899 currentBlock && 13900 // presence of a patch flag indicates this node needs patching on updates. 13901 // component nodes also should always be patched, because even if the 13902 // component doesn't need to update, it needs to persist the instance on to 13903 // the next vnode so that it can be properly unmounted later. 13904 (vnode.patchFlag > 0 || shapeFlag & 6 /* ShapeFlags.COMPONENT */) && 13905 // the EVENTS flag is only for hydration and if it is the only flag, the 13906 // vnode should not be considered dynamic due to handler caching. 13907 vnode.patchFlag !== 32 /* PatchFlags.HYDRATE_EVENTS */) { 13908 currentBlock.push(vnode); 13909 } 13910 return vnode; 13911} 13912const createVNode = (( true) ? createVNodeWithArgsTransform : 0); 13913function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) { 13914 if (!type || type === NULL_DYNAMIC_COMPONENT) { 13915 if (( true) && !type) { 13916 warn(`Invalid vnode type when creating vnode: ${type}.`); 13917 } 13918 type = Comment; 13919 } 13920 if (isVNode(type)) { 13921 // createVNode receiving an existing vnode. This happens in cases like 13922 // <component :is="vnode"/> 13923 // #2078 make sure to merge refs during the clone instead of overwriting it 13924 const cloned = cloneVNode(type, props, true /* mergeRef: true */); 13925 if (children) { 13926 normalizeChildren(cloned, children); 13927 } 13928 if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) { 13929 if (cloned.shapeFlag & 6 /* ShapeFlags.COMPONENT */) { 13930 currentBlock[currentBlock.indexOf(type)] = cloned; 13931 } 13932 else { 13933 currentBlock.push(cloned); 13934 } 13935 } 13936 cloned.patchFlag |= -2 /* PatchFlags.BAIL */; 13937 return cloned; 13938 } 13939 // class component normalization. 13940 if (isClassComponent(type)) { 13941 type = type.__vccOpts; 13942 } 13943 // class & style normalization. 13944 if (props) { 13945 // for reactive or proxy objects, we need to clone it to enable mutation. 13946 props = guardReactiveProps(props); 13947 let { class: klass, style } = props; 13948 if (klass && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(klass)) { 13949 props.class = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass)(klass); 13950 } 13951 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(style)) { 13952 // reactive state objects need to be cloned since they are likely to be 13953 // mutated 13954 if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy)(style) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(style)) { 13955 style = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, style); 13956 } 13957 props.style = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle)(style); 13958 } 13959 } 13960 // encode the vnode type information into a bitmap 13961 const shapeFlag = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(type) 13962 ? 1 /* ShapeFlags.ELEMENT */ 13963 : isSuspense(type) 13964 ? 128 /* ShapeFlags.SUSPENSE */ 13965 : isTeleport(type) 13966 ? 64 /* ShapeFlags.TELEPORT */ 13967 : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(type) 13968 ? 4 /* ShapeFlags.STATEFUL_COMPONENT */ 13969 : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(type) 13970 ? 2 /* ShapeFlags.FUNCTIONAL_COMPONENT */ 13971 : 0; 13972 if (( true) && shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */ && (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy)(type)) { 13973 type = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(type); 13974 warn(`Vue received a Component which was made a reactive object. This can ` + 13975 `lead to unnecessary performance overhead, and should be avoided by ` + 13976 `marking the component with \`markRaw\` or using \`shallowRef\` ` + 13977 `instead of \`ref\`.`, `\nComponent that was made reactive: `, type); 13978 } 13979 return createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, isBlockNode, true); 13980} 13981function guardReactiveProps(props) { 13982 if (!props) 13983 return null; 13984 return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy)(props) || InternalObjectKey in props 13985 ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, props) 13986 : props; 13987} 13988function cloneVNode(vnode, extraProps, mergeRef = false) { 13989 // This is intentionally NOT using spread or extend to avoid the runtime 13990 // key enumeration cost. 13991 const { props, ref, patchFlag, children } = vnode; 13992 const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props; 13993 const cloned = { 13994 __v_isVNode: true, 13995 __v_skip: true, 13996 type: vnode.type, 13997 props: mergedProps, 13998 key: mergedProps && normalizeKey(mergedProps), 13999 ref: extraProps && extraProps.ref 14000 ? // #2078 in the case of <component :is="vnode" ref="extra"/> 14001 // if the vnode itself already has a ref, cloneVNode will need to merge 14002 // the refs so the single vnode can be set on multiple refs 14003 mergeRef && ref 14004 ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(ref) 14005 ? ref.concat(normalizeRef(extraProps)) 14006 : [ref, normalizeRef(extraProps)] 14007 : normalizeRef(extraProps) 14008 : ref, 14009 scopeId: vnode.scopeId, 14010 slotScopeIds: vnode.slotScopeIds, 14011 children: ( true) && patchFlag === -1 /* PatchFlags.HOISTED */ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(children) 14012 ? children.map(deepCloneVNode) 14013 : children, 14014 target: vnode.target, 14015 targetAnchor: vnode.targetAnchor, 14016 staticCount: vnode.staticCount, 14017 shapeFlag: vnode.shapeFlag, 14018 // if the vnode is cloned with extra props, we can no longer assume its 14019 // existing patch flag to be reliable and need to add the FULL_PROPS flag. 14020 // note: preserve flag for fragments since they use the flag for children 14021 // fast paths only. 14022 patchFlag: extraProps && vnode.type !== Fragment 14023 ? patchFlag === -1 // hoisted node 14024 ? 16 /* PatchFlags.FULL_PROPS */ 14025 : patchFlag | 16 /* PatchFlags.FULL_PROPS */ 14026 : patchFlag, 14027 dynamicProps: vnode.dynamicProps, 14028 dynamicChildren: vnode.dynamicChildren, 14029 appContext: vnode.appContext, 14030 dirs: vnode.dirs, 14031 transition: vnode.transition, 14032 // These should technically only be non-null on mounted VNodes. However, 14033 // they *should* be copied for kept-alive vnodes. So we just always copy 14034 // them since them being non-null during a mount doesn't affect the logic as 14035 // they will simply be overwritten. 14036 component: vnode.component, 14037 suspense: vnode.suspense, 14038 ssContent: vnode.ssContent && cloneVNode(vnode.ssContent), 14039 ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback), 14040 el: vnode.el, 14041 anchor: vnode.anchor, 14042 ctx: vnode.ctx 14043 }; 14044 return cloned; 14045} 14046/** 14047 * Dev only, for HMR of hoisted vnodes reused in v-for 14048 * https://github.com/vitejs/vite/issues/2022 14049 */ 14050function deepCloneVNode(vnode) { 14051 const cloned = cloneVNode(vnode); 14052 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(vnode.children)) { 14053 cloned.children = vnode.children.map(deepCloneVNode); 14054 } 14055 return cloned; 14056} 14057/** 14058 * @private 14059 */ 14060function createTextVNode(text = ' ', flag = 0) { 14061 return createVNode(Text, null, text, flag); 14062} 14063/** 14064 * @private 14065 */ 14066function createStaticVNode(content, numberOfNodes) { 14067 // A static vnode can contain multiple stringified elements, and the number 14068 // of elements is necessary for hydration. 14069 const vnode = createVNode(Static, null, content); 14070 vnode.staticCount = numberOfNodes; 14071 return vnode; 14072} 14073/** 14074 * @private 14075 */ 14076function createCommentVNode(text = '', 14077// when used as the v-else branch, the comment node must be created as a 14078// block to ensure correct updates. 14079asBlock = false) { 14080 return asBlock 14081 ? (openBlock(), createBlock(Comment, null, text)) 14082 : createVNode(Comment, null, text); 14083} 14084function normalizeVNode(child) { 14085 if (child == null || typeof child === 'boolean') { 14086 // empty placeholder 14087 return createVNode(Comment); 14088 } 14089 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(child)) { 14090 // fragment 14091 return createVNode(Fragment, null, 14092 // #3666, avoid reference pollution when reusing vnode 14093 child.slice()); 14094 } 14095 else if (typeof child === 'object') { 14096 // already vnode, this should be the most common since compiled templates 14097 // always produce all-vnode children arrays 14098 return cloneIfMounted(child); 14099 } 14100 else { 14101 // strings and numbers 14102 return createVNode(Text, null, String(child)); 14103 } 14104} 14105// optimized normalization for template-compiled render fns 14106function cloneIfMounted(child) { 14107 return (child.el === null && child.patchFlag !== -1 /* PatchFlags.HOISTED */) || 14108 child.memo 14109 ? child 14110 : cloneVNode(child); 14111} 14112function normalizeChildren(vnode, children) { 14113 let type = 0; 14114 const { shapeFlag } = vnode; 14115 if (children == null) { 14116 children = null; 14117 } 14118 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(children)) { 14119 type = 16 /* ShapeFlags.ARRAY_CHILDREN */; 14120 } 14121 else if (typeof children === 'object') { 14122 if (shapeFlag & (1 /* ShapeFlags.ELEMENT */ | 64 /* ShapeFlags.TELEPORT */)) { 14123 // Normalize slot to plain children for plain element and Teleport 14124 const slot = children.default; 14125 if (slot) { 14126 // _c marker is added by withCtx() indicating this is a compiled slot 14127 slot._c && (slot._d = false); 14128 normalizeChildren(vnode, slot()); 14129 slot._c && (slot._d = true); 14130 } 14131 return; 14132 } 14133 else { 14134 type = 32 /* ShapeFlags.SLOTS_CHILDREN */; 14135 const slotFlag = children._; 14136 if (!slotFlag && !(InternalObjectKey in children)) { 14137 children._ctx = currentRenderingInstance; 14138 } 14139 else if (slotFlag === 3 /* SlotFlags.FORWARDED */ && currentRenderingInstance) { 14140 // a child component receives forwarded slots from the parent. 14141 // its slot type is determined by its parent's slot type. 14142 if (currentRenderingInstance.slots._ === 1 /* SlotFlags.STABLE */) { 14143 children._ = 1 /* SlotFlags.STABLE */; 14144 } 14145 else { 14146 children._ = 2 /* SlotFlags.DYNAMIC */; 14147 vnode.patchFlag |= 1024 /* PatchFlags.DYNAMIC_SLOTS */; 14148 } 14149 } 14150 } 14151 } 14152 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(children)) { 14153 children = { default: children, _ctx: currentRenderingInstance }; 14154 type = 32 /* ShapeFlags.SLOTS_CHILDREN */; 14155 } 14156 else { 14157 children = String(children); 14158 // force teleport children to array so it can be moved around 14159 if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) { 14160 type = 16 /* ShapeFlags.ARRAY_CHILDREN */; 14161 children = [createTextVNode(children)]; 14162 } 14163 else { 14164 type = 8 /* ShapeFlags.TEXT_CHILDREN */; 14165 } 14166 } 14167 vnode.children = children; 14168 vnode.shapeFlag |= type; 14169} 14170function mergeProps(...args) { 14171 const ret = {}; 14172 for (let i = 0; i < args.length; i++) { 14173 const toMerge = args[i]; 14174 for (const key in toMerge) { 14175 if (key === 'class') { 14176 if (ret.class !== toMerge.class) { 14177 ret.class = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass)([ret.class, toMerge.class]); 14178 } 14179 } 14180 else if (key === 'style') { 14181 ret.style = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle)([ret.style, toMerge.style]); 14182 } 14183 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) { 14184 const existing = ret[key]; 14185 const incoming = toMerge[key]; 14186 if (incoming && 14187 existing !== incoming && 14188 !((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(existing) && existing.includes(incoming))) { 14189 ret[key] = existing 14190 ? [].concat(existing, incoming) 14191 : incoming; 14192 } 14193 } 14194 else if (key !== '') { 14195 ret[key] = toMerge[key]; 14196 } 14197 } 14198 } 14199 return ret; 14200} 14201function invokeVNodeHook(hook, instance, vnode, prevVNode = null) { 14202 callWithAsyncErrorHandling(hook, instance, 7 /* ErrorCodes.VNODE_HOOK */, [ 14203 vnode, 14204 prevVNode 14205 ]); 14206} 14207 14208const emptyAppContext = createAppContext(); 14209let uid$1 = 0; 14210function createComponentInstance(vnode, parent, suspense) { 14211 const type = vnode.type; 14212 // inherit parent app context - or - if root, adopt from root vnode 14213 const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext; 14214 const instance = { 14215 uid: uid$1++, 14216 vnode, 14217 type, 14218 parent, 14219 appContext, 14220 root: null, 14221 next: null, 14222 subTree: null, 14223 effect: null, 14224 update: null, 14225 scope: new _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.EffectScope(true /* detached */), 14226 render: null, 14227 proxy: null, 14228 exposed: null, 14229 exposeProxy: null, 14230 withProxy: null, 14231 provides: parent ? parent.provides : Object.create(appContext.provides), 14232 accessCache: null, 14233 renderCache: [], 14234 // local resolved assets 14235 components: null, 14236 directives: null, 14237 // resolved props and emits options 14238 propsOptions: normalizePropsOptions(type, appContext), 14239 emitsOptions: normalizeEmitsOptions(type, appContext), 14240 // emit 14241 emit: null, 14242 emitted: null, 14243 // props default value 14244 propsDefaults: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 14245 // inheritAttrs 14246 inheritAttrs: type.inheritAttrs, 14247 // state 14248 ctx: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 14249 data: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 14250 props: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 14251 attrs: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 14252 slots: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 14253 refs: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 14254 setupState: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ, 14255 setupContext: null, 14256 // suspense related 14257 suspense, 14258 suspenseId: suspense ? suspense.pendingId : 0, 14259 asyncDep: null, 14260 asyncResolved: false, 14261 // lifecycle hooks 14262 // not using enums here because it results in computed properties 14263 isMounted: false, 14264 isUnmounted: false, 14265 isDeactivated: false, 14266 bc: null, 14267 c: null, 14268 bm: null, 14269 m: null, 14270 bu: null, 14271 u: null, 14272 um: null, 14273 bum: null, 14274 da: null, 14275 a: null, 14276 rtg: null, 14277 rtc: null, 14278 ec: null, 14279 sp: null 14280 }; 14281 if ((true)) { 14282 instance.ctx = createDevRenderContext(instance); 14283 } 14284 else {} 14285 instance.root = parent ? parent.root : instance; 14286 instance.emit = emit$1.bind(null, instance); 14287 // apply custom element special handling 14288 if (vnode.ce) { 14289 vnode.ce(instance); 14290 } 14291 return instance; 14292} 14293let currentInstance = null; 14294const getCurrentInstance = () => currentInstance || currentRenderingInstance; 14295const setCurrentInstance = (instance) => { 14296 currentInstance = instance; 14297 instance.scope.on(); 14298}; 14299const unsetCurrentInstance = () => { 14300 currentInstance && currentInstance.scope.off(); 14301 currentInstance = null; 14302}; 14303const isBuiltInTag = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)('slot,component'); 14304function validateComponentName(name, config) { 14305 const appIsNativeTag = config.isNativeTag || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NO; 14306 if (isBuiltInTag(name) || appIsNativeTag(name)) { 14307 warn('Do not use built-in or reserved HTML elements as component id: ' + name); 14308 } 14309} 14310function isStatefulComponent(instance) { 14311 return instance.vnode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */; 14312} 14313let isInSSRComponentSetup = false; 14314function setupComponent(instance, isSSR = false) { 14315 isInSSRComponentSetup = isSSR; 14316 const { props, children } = instance.vnode; 14317 const isStateful = isStatefulComponent(instance); 14318 initProps(instance, props, isStateful, isSSR); 14319 initSlots(instance, children); 14320 const setupResult = isStateful 14321 ? setupStatefulComponent(instance, isSSR) 14322 : undefined; 14323 isInSSRComponentSetup = false; 14324 return setupResult; 14325} 14326function setupStatefulComponent(instance, isSSR) { 14327 var _a; 14328 const Component = instance.type; 14329 if ((true)) { 14330 if (Component.name) { 14331 validateComponentName(Component.name, instance.appContext.config); 14332 } 14333 if (Component.components) { 14334 const names = Object.keys(Component.components); 14335 for (let i = 0; i < names.length; i++) { 14336 validateComponentName(names[i], instance.appContext.config); 14337 } 14338 } 14339 if (Component.directives) { 14340 const names = Object.keys(Component.directives); 14341 for (let i = 0; i < names.length; i++) { 14342 validateDirectiveName(names[i]); 14343 } 14344 } 14345 if (Component.compilerOptions && isRuntimeOnly()) { 14346 warn(`"compilerOptions" is only supported when using a build of Vue that ` + 14347 `includes the runtime compiler. Since you are using a runtime-only ` + 14348 `build, the options should be passed via your build tool config instead.`); 14349 } 14350 } 14351 // 0. create render proxy property access cache 14352 instance.accessCache = Object.create(null); 14353 // 1. create public instance / render proxy 14354 // also mark it raw so it's never observed 14355 instance.proxy = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.markRaw)(new Proxy(instance.ctx, PublicInstanceProxyHandlers)); 14356 if ((true)) { 14357 exposePropsOnRenderContext(instance); 14358 } 14359 // 2. call setup() 14360 const { setup } = Component; 14361 if (setup) { 14362 const setupContext = (instance.setupContext = 14363 setup.length > 1 ? createSetupContext(instance) : null); 14364 setCurrentInstance(instance); 14365 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 14366 const setupResult = callWithErrorHandling(setup, instance, 0 /* ErrorCodes.SETUP_FUNCTION */, [( true) ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(instance.props) : 0, setupContext]); 14367 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 14368 unsetCurrentInstance(); 14369 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(setupResult)) { 14370 setupResult.then(unsetCurrentInstance, unsetCurrentInstance); 14371 if (isSSR) { 14372 // return the promise so server-renderer can wait on it 14373 return setupResult 14374 .then((resolvedResult) => { 14375 handleSetupResult(instance, resolvedResult, isSSR); 14376 }) 14377 .catch(e => { 14378 handleError(e, instance, 0 /* ErrorCodes.SETUP_FUNCTION */); 14379 }); 14380 } 14381 else { 14382 // async setup returned Promise. 14383 // bail here and wait for re-entry. 14384 instance.asyncDep = setupResult; 14385 if (( true) && !instance.suspense) { 14386 const name = (_a = Component.name) !== null && _a !== void 0 ? _a : 'Anonymous'; 14387 warn(`Component <${name}>: setup function returned a promise, but no ` + 14388 `<Suspense> boundary was found in the parent component tree. ` + 14389 `A component with async setup() must be nested in a <Suspense> ` + 14390 `in order to be rendered.`); 14391 } 14392 } 14393 } 14394 else { 14395 handleSetupResult(instance, setupResult, isSSR); 14396 } 14397 } 14398 else { 14399 finishComponentSetup(instance, isSSR); 14400 } 14401} 14402function handleSetupResult(instance, setupResult, isSSR) { 14403 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(setupResult)) { 14404 // setup returned an inline render function 14405 if (instance.type.__ssrInlineRender) { 14406 // when the function's name is `ssrRender` (compiled by SFC inline mode), 14407 // set it as ssrRender instead. 14408 instance.ssrRender = setupResult; 14409 } 14410 else { 14411 instance.render = setupResult; 14412 } 14413 } 14414 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(setupResult)) { 14415 if (( true) && isVNode(setupResult)) { 14416 warn(`setup() should not return VNodes directly - ` + 14417 `return a render function instead.`); 14418 } 14419 // setup returned bindings. 14420 // assuming a render function compiled from template is present. 14421 if (true) { 14422 instance.devtoolsRawSetupState = setupResult; 14423 } 14424 instance.setupState = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.proxyRefs)(setupResult); 14425 if ((true)) { 14426 exposeSetupStateOnRenderContext(instance); 14427 } 14428 } 14429 else if (( true) && setupResult !== undefined) { 14430 warn(`setup() should return an object. Received: ${setupResult === null ? 'null' : typeof setupResult}`); 14431 } 14432 finishComponentSetup(instance, isSSR); 14433} 14434let compile; 14435let installWithProxy; 14436/** 14437 * For runtime-dom to register the compiler. 14438 * Note the exported method uses any to avoid d.ts relying on the compiler types. 14439 */ 14440function registerRuntimeCompiler(_compile) { 14441 compile = _compile; 14442 installWithProxy = i => { 14443 if (i.render._rc) { 14444 i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers); 14445 } 14446 }; 14447} 14448// dev only 14449const isRuntimeOnly = () => !compile; 14450function finishComponentSetup(instance, isSSR, skipOptions) { 14451 const Component = instance.type; 14452 // template / render function normalization 14453 // could be already set when returned from setup() 14454 if (!instance.render) { 14455 // only do on-the-fly compile if not in SSR - SSR on-the-fly compilation 14456 // is done by server-renderer 14457 if (!isSSR && compile && !Component.render) { 14458 const template = Component.template || 14459 resolveMergedOptions(instance).template; 14460 if (template) { 14461 if ((true)) { 14462 startMeasure(instance, `compile`); 14463 } 14464 const { isCustomElement, compilerOptions } = instance.appContext.config; 14465 const { delimiters, compilerOptions: componentCompilerOptions } = Component; 14466 const finalCompilerOptions = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({ 14467 isCustomElement, 14468 delimiters 14469 }, compilerOptions), componentCompilerOptions); 14470 Component.render = compile(template, finalCompilerOptions); 14471 if ((true)) { 14472 endMeasure(instance, `compile`); 14473 } 14474 } 14475 } 14476 instance.render = (Component.render || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP); 14477 // for runtime-compiled render functions using `with` blocks, the render 14478 // proxy used needs a different `has` handler which is more performant and 14479 // also only allows a whitelist of globals to fallthrough. 14480 if (installWithProxy) { 14481 installWithProxy(instance); 14482 } 14483 } 14484 // support for 2.x options 14485 if (true) { 14486 setCurrentInstance(instance); 14487 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)(); 14488 applyOptions(instance); 14489 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)(); 14490 unsetCurrentInstance(); 14491 } 14492 // warn missing template/render 14493 // the runtime compilation of template in SSR is done by server-render 14494 if (( true) && !Component.render && instance.render === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP && !isSSR) { 14495 /* istanbul ignore if */ 14496 if (!compile && Component.template) { 14497 warn(`Component provided template option but ` + 14498 `runtime compilation is not supported in this build of Vue.` + 14499 (` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".` 14500 ) /* should not happen */); 14501 } 14502 else { 14503 warn(`Component is missing template or render function.`); 14504 } 14505 } 14506} 14507function createAttrsProxy(instance) { 14508 return new Proxy(instance.attrs, ( true) 14509 ? { 14510 get(target, key) { 14511 markAttrsAccessed(); 14512 (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.track)(instance, "get" /* TrackOpTypes.GET */, '$attrs'); 14513 return target[key]; 14514 }, 14515 set() { 14516 warn(`setupContext.attrs is readonly.`); 14517 return false; 14518 }, 14519 deleteProperty() { 14520 warn(`setupContext.attrs is readonly.`); 14521 return false; 14522 } 14523 } 14524 : 0); 14525} 14526function createSetupContext(instance) { 14527 const expose = exposed => { 14528 if (( true) && instance.exposed) { 14529 warn(`expose() should be called only once per setup().`); 14530 } 14531 instance.exposed = exposed || {}; 14532 }; 14533 let attrs; 14534 if ((true)) { 14535 // We use getters in dev in case libs like test-utils overwrite instance 14536 // properties (overwrites should not be done in prod) 14537 return Object.freeze({ 14538 get attrs() { 14539 return attrs || (attrs = createAttrsProxy(instance)); 14540 }, 14541 get slots() { 14542 return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(instance.slots); 14543 }, 14544 get emit() { 14545 return (event, ...args) => instance.emit(event, ...args); 14546 }, 14547 expose 14548 }); 14549 } 14550 else {} 14551} 14552function getExposeProxy(instance) { 14553 if (instance.exposed) { 14554 return (instance.exposeProxy || 14555 (instance.exposeProxy = new Proxy((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.proxyRefs)((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.markRaw)(instance.exposed)), { 14556 get(target, key) { 14557 if (key in target) { 14558 return target[key]; 14559 } 14560 else if (key in publicPropertiesMap) { 14561 return publicPropertiesMap[key](instance); 14562 } 14563 }, 14564 has(target, key) { 14565 return key in target || key in publicPropertiesMap; 14566 } 14567 }))); 14568 } 14569} 14570const classifyRE = /(?:^|[-_])(\w)/g; 14571const classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, ''); 14572function getComponentName(Component, includeInferred = true) { 14573 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(Component) 14574 ? Component.displayName || Component.name 14575 : Component.name || (includeInferred && Component.__name); 14576} 14577/* istanbul ignore next */ 14578function formatComponentName(instance, Component, isRoot = false) { 14579 let name = getComponentName(Component); 14580 if (!name && Component.__file) { 14581 const match = Component.__file.match(/([^/\\]+)\.\w+$/); 14582 if (match) { 14583 name = match[1]; 14584 } 14585 } 14586 if (!name && instance && instance.parent) { 14587 // try to infer the name based on reverse resolution 14588 const inferFromRegistry = (registry) => { 14589 for (const key in registry) { 14590 if (registry[key] === Component) { 14591 return key; 14592 } 14593 } 14594 }; 14595 name = 14596 inferFromRegistry(instance.components || 14597 instance.parent.type.components) || inferFromRegistry(instance.appContext.components); 14598 } 14599 return name ? classify(name) : isRoot ? `App` : `Anonymous`; 14600} 14601function isClassComponent(value) { 14602 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value) && '__vccOpts' in value; 14603} 14604 14605const computed = ((getterOrOptions, debugOptions) => { 14606 // @ts-ignore 14607 return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.computed)(getterOrOptions, debugOptions, isInSSRComponentSetup); 14608}); 14609 14610// dev only 14611const warnRuntimeUsage = (method) => warn(`${method}() is a compiler-hint helper that is only usable inside ` + 14612 `<script setup> of a single file component. Its arguments should be ` + 14613 `compiled away and passing it at runtime has no effect.`); 14614// implementation 14615function defineProps() { 14616 if ((true)) { 14617 warnRuntimeUsage(`defineProps`); 14618 } 14619 return null; 14620} 14621// implementation 14622function defineEmits() { 14623 if ((true)) { 14624 warnRuntimeUsage(`defineEmits`); 14625 } 14626 return null; 14627} 14628/** 14629 * Vue `<script setup>` compiler macro for declaring a component's exposed 14630 * instance properties when it is accessed by a parent component via template 14631 * refs. 14632 * 14633 * `<script setup>` components are closed by default - i.e. variables inside 14634 * the `<script setup>` scope is not exposed to parent unless explicitly exposed 14635 * via `defineExpose`. 14636 * 14637 * This is only usable inside `<script setup>`, is compiled away in the 14638 * output and should **not** be actually called at runtime. 14639 */ 14640function defineExpose(exposed) { 14641 if ((true)) { 14642 warnRuntimeUsage(`defineExpose`); 14643 } 14644} 14645/** 14646 * Vue `<script setup>` compiler macro for providing props default values when 14647 * using type-based `defineProps` declaration. 14648 * 14649 * Example usage: 14650 * ```ts 14651 * withDefaults(defineProps<{ 14652 * size?: number 14653 * labels?: string[] 14654 * }>(), { 14655 * size: 3, 14656 * labels: () => ['default label'] 14657 * }) 14658 * ``` 14659 * 14660 * This is only usable inside `<script setup>`, is compiled away in the output 14661 * and should **not** be actually called at runtime. 14662 */ 14663function withDefaults(props, defaults) { 14664 if ((true)) { 14665 warnRuntimeUsage(`withDefaults`); 14666 } 14667 return null; 14668} 14669function useSlots() { 14670 return getContext().slots; 14671} 14672function useAttrs() { 14673 return getContext().attrs; 14674} 14675function getContext() { 14676 const i = getCurrentInstance(); 14677 if (( true) && !i) { 14678 warn(`useContext() called without active instance.`); 14679 } 14680 return i.setupContext || (i.setupContext = createSetupContext(i)); 14681} 14682/** 14683 * Runtime helper for merging default declarations. Imported by compiled code 14684 * only. 14685 * @internal 14686 */ 14687function mergeDefaults(raw, defaults) { 14688 const props = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw) 14689 ? raw.reduce((normalized, p) => ((normalized[p] = {}), normalized), {}) 14690 : raw; 14691 for (const key in defaults) { 14692 const opt = props[key]; 14693 if (opt) { 14694 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(opt) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt)) { 14695 props[key] = { type: opt, default: defaults[key] }; 14696 } 14697 else { 14698 opt.default = defaults[key]; 14699 } 14700 } 14701 else if (opt === null) { 14702 props[key] = { default: defaults[key] }; 14703 } 14704 else if ((true)) { 14705 warn(`props default key "${key}" has no corresponding declaration.`); 14706 } 14707 } 14708 return props; 14709} 14710/** 14711 * Used to create a proxy for the rest element when destructuring props with 14712 * defineProps(). 14713 * @internal 14714 */ 14715function createPropsRestProxy(props, excludedKeys) { 14716 const ret = {}; 14717 for (const key in props) { 14718 if (!excludedKeys.includes(key)) { 14719 Object.defineProperty(ret, key, { 14720 enumerable: true, 14721 get: () => props[key] 14722 }); 14723 } 14724 } 14725 return ret; 14726} 14727/** 14728 * `<script setup>` helper for persisting the current instance context over 14729 * async/await flows. 14730 * 14731 * `@vue/compiler-sfc` converts the following: 14732 * 14733 * ```ts 14734 * const x = await foo() 14735 * ``` 14736 * 14737 * into: 14738 * 14739 * ```ts 14740 * let __temp, __restore 14741 * const x = (([__temp, __restore] = withAsyncContext(() => foo())),__temp=await __temp,__restore(),__temp) 14742 * ``` 14743 * @internal 14744 */ 14745function withAsyncContext(getAwaitable) { 14746 const ctx = getCurrentInstance(); 14747 if (( true) && !ctx) { 14748 warn(`withAsyncContext called without active current instance. ` + 14749 `This is likely a bug.`); 14750 } 14751 let awaitable = getAwaitable(); 14752 unsetCurrentInstance(); 14753 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(awaitable)) { 14754 awaitable = awaitable.catch(e => { 14755 setCurrentInstance(ctx); 14756 throw e; 14757 }); 14758 } 14759 return [awaitable, () => setCurrentInstance(ctx)]; 14760} 14761 14762// Actual implementation 14763function h(type, propsOrChildren, children) { 14764 const l = arguments.length; 14765 if (l === 2) { 14766 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(propsOrChildren) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(propsOrChildren)) { 14767 // single vnode without props 14768 if (isVNode(propsOrChildren)) { 14769 return createVNode(type, null, [propsOrChildren]); 14770 } 14771 // props without children 14772 return createVNode(type, propsOrChildren); 14773 } 14774 else { 14775 // omit props 14776 return createVNode(type, null, propsOrChildren); 14777 } 14778 } 14779 else { 14780 if (l > 3) { 14781 children = Array.prototype.slice.call(arguments, 2); 14782 } 14783 else if (l === 3 && isVNode(children)) { 14784 children = [children]; 14785 } 14786 return createVNode(type, propsOrChildren, children); 14787 } 14788} 14789 14790const ssrContextKey = Symbol(( true) ? `ssrContext` : 0); 14791const useSSRContext = () => { 14792 { 14793 const ctx = inject(ssrContextKey); 14794 if (!ctx) { 14795 ( true) && 14796 warn(`Server rendering context not provided. Make sure to only call ` + 14797 `useSSRContext() conditionally in the server build.`); 14798 } 14799 return ctx; 14800 } 14801}; 14802 14803function isShallow(value) { 14804 return !!(value && value["__v_isShallow" /* ReactiveFlags.IS_SHALLOW */]); 14805} 14806 14807function initCustomFormatter() { 14808 /* eslint-disable no-restricted-globals */ 14809 if ( false || typeof window === 'undefined') { 14810 return; 14811 } 14812 const vueStyle = { style: 'color:#3ba776' }; 14813 const numberStyle = { style: 'color:#0b1bc9' }; 14814 const stringStyle = { style: 'color:#b62e24' }; 14815 const keywordStyle = { style: 'color:#9d288c' }; 14816 // custom formatter for Chrome 14817 // https://www.mattzeunert.com/2016/02/19/custom-chrome-devtools-object-formatters.html 14818 const formatter = { 14819 header(obj) { 14820 // TODO also format ComponentPublicInstance & ctx.slots/attrs in setup 14821 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(obj)) { 14822 return null; 14823 } 14824 if (obj.__isVue) { 14825 return ['div', vueStyle, `VueInstance`]; 14826 } 14827 else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(obj)) { 14828 return [ 14829 'div', 14830 {}, 14831 ['span', vueStyle, genRefFlag(obj)], 14832 '<', 14833 formatValue(obj.value), 14834 `>` 14835 ]; 14836 } 14837 else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive)(obj)) { 14838 return [ 14839 'div', 14840 {}, 14841 ['span', vueStyle, isShallow(obj) ? 'ShallowReactive' : 'Reactive'], 14842 '<', 14843 formatValue(obj), 14844 `>${(0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReadonly)(obj) ? ` (readonly)` : ``}` 14845 ]; 14846 } 14847 else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReadonly)(obj)) { 14848 return [ 14849 'div', 14850 {}, 14851 ['span', vueStyle, isShallow(obj) ? 'ShallowReadonly' : 'Readonly'], 14852 '<', 14853 formatValue(obj), 14854 '>' 14855 ]; 14856 } 14857 return null; 14858 }, 14859 hasBody(obj) { 14860 return obj && obj.__isVue; 14861 }, 14862 body(obj) { 14863 if (obj && obj.__isVue) { 14864 return [ 14865 'div', 14866 {}, 14867 ...formatInstance(obj.$) 14868 ]; 14869 } 14870 } 14871 }; 14872 function formatInstance(instance) { 14873 const blocks = []; 14874 if (instance.type.props && instance.props) { 14875 blocks.push(createInstanceBlock('props', (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(instance.props))); 14876 } 14877 if (instance.setupState !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) { 14878 blocks.push(createInstanceBlock('setup', instance.setupState)); 14879 } 14880 if (instance.data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) { 14881 blocks.push(createInstanceBlock('data', (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(instance.data))); 14882 } 14883 const computed = extractKeys(instance, 'computed'); 14884 if (computed) { 14885 blocks.push(createInstanceBlock('computed', computed)); 14886 } 14887 const injected = extractKeys(instance, 'inject'); 14888 if (injected) { 14889 blocks.push(createInstanceBlock('injected', injected)); 14890 } 14891 blocks.push([ 14892 'div', 14893 {}, 14894 [ 14895 'span', 14896 { 14897 style: keywordStyle.style + ';opacity:0.66' 14898 }, 14899 '$ (internal): ' 14900 ], 14901 ['object', { object: instance }] 14902 ]); 14903 return blocks; 14904 } 14905 function createInstanceBlock(type, target) { 14906 target = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, target); 14907 if (!Object.keys(target).length) { 14908 return ['span', {}]; 14909 } 14910 return [ 14911 'div', 14912 { style: 'line-height:1.25em;margin-bottom:0.6em' }, 14913 [ 14914 'div', 14915 { 14916 style: 'color:#476582' 14917 }, 14918 type 14919 ], 14920 [ 14921 'div', 14922 { 14923 style: 'padding-left:1.25em' 14924 }, 14925 ...Object.keys(target).map(key => { 14926 return [ 14927 'div', 14928 {}, 14929 ['span', keywordStyle, key + ': '], 14930 formatValue(target[key], false) 14931 ]; 14932 }) 14933 ] 14934 ]; 14935 } 14936 function formatValue(v, asRaw = true) { 14937 if (typeof v === 'number') { 14938 return ['span', numberStyle, v]; 14939 } 14940 else if (typeof v === 'string') { 14941 return ['span', stringStyle, JSON.stringify(v)]; 14942 } 14943 else if (typeof v === 'boolean') { 14944 return ['span', keywordStyle, v]; 14945 } 14946 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(v)) { 14947 return ['object', { object: asRaw ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(v) : v }]; 14948 } 14949 else { 14950 return ['span', stringStyle, String(v)]; 14951 } 14952 } 14953 function extractKeys(instance, type) { 14954 const Comp = instance.type; 14955 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(Comp)) { 14956 return; 14957 } 14958 const extracted = {}; 14959 for (const key in instance.ctx) { 14960 if (isKeyOfType(Comp, key, type)) { 14961 extracted[key] = instance.ctx[key]; 14962 } 14963 } 14964 return extracted; 14965 } 14966 function isKeyOfType(Comp, key, type) { 14967 const opts = Comp[type]; 14968 if (((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(opts) && opts.includes(key)) || 14969 ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(opts) && key in opts)) { 14970 return true; 14971 } 14972 if (Comp.extends && isKeyOfType(Comp.extends, key, type)) { 14973 return true; 14974 } 14975 if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) { 14976 return true; 14977 } 14978 } 14979 function genRefFlag(v) { 14980 if (isShallow(v)) { 14981 return `ShallowRef`; 14982 } 14983 if (v.effect) { 14984 return `ComputedRef`; 14985 } 14986 return `Ref`; 14987 } 14988 if (window.devtoolsFormatters) { 14989 window.devtoolsFormatters.push(formatter); 14990 } 14991 else { 14992 window.devtoolsFormatters = [formatter]; 14993 } 14994} 14995 14996function withMemo(memo, render, cache, index) { 14997 const cached = cache[index]; 14998 if (cached && isMemoSame(cached, memo)) { 14999 return cached; 15000 } 15001 const ret = render(); 15002 // shallow clone 15003 ret.memo = memo.slice(); 15004 return (cache[index] = ret); 15005} 15006function isMemoSame(cached, memo) { 15007 const prev = cached.memo; 15008 if (prev.length != memo.length) { 15009 return false; 15010 } 15011 for (let i = 0; i < prev.length; i++) { 15012 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(prev[i], memo[i])) { 15013 return false; 15014 } 15015 } 15016 // make sure to let parent block track it when returning cached 15017 if (isBlockTreeEnabled > 0 && currentBlock) { 15018 currentBlock.push(cached); 15019 } 15020 return true; 15021} 15022 15023// Core API ------------------------------------------------------------------ 15024const version = "3.2.45"; 15025const _ssrUtils = { 15026 createComponentInstance, 15027 setupComponent, 15028 renderComponentRoot, 15029 setCurrentRenderingInstance, 15030 isVNode, 15031 normalizeVNode 15032}; 15033/** 15034 * SSR utils for \@vue/server-renderer. Only exposed in ssr-possible builds. 15035 * @internal 15036 */ 15037const ssrUtils = (_ssrUtils ); 15038/** 15039 * @internal only exposed in compat builds 15040 */ 15041const resolveFilter = null; 15042/** 15043 * @internal only exposed in compat builds. 15044 */ 15045const compatUtils = (null); 15046 15047 15048 15049 15050/***/ }), 15051
vendor: 84,632 bytes, lines 15052-16912
15052/***/ "./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js": 15053/*!***********************************************************************!*\ 15054 !*** ./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js ***! 15055 \***********************************************************************/ 15056/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 15057 15058"use strict"; 15059__webpack_require__.r(__webpack_exports__); 15060/* harmony export */ __webpack_require__.d(__webpack_exports__, { 15061/* harmony export */ "BaseTransition": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransition; }, 15062/* harmony export */ "Comment": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Comment; }, 15063/* harmony export */ "EffectScope": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.EffectScope; }, 15064/* harmony export */ "Fragment": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Fragment; }, 15065/* harmony export */ "KeepAlive": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.KeepAlive; }, 15066/* harmony export */ "ReactiveEffect": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect; }, 15067/* harmony export */ "Static": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Static; }, 15068/* harmony export */ "Suspense": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Suspense; }, 15069/* harmony export */ "Teleport": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Teleport; }, 15070/* harmony export */ "Text": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Text; }, 15071/* harmony export */ "Transition": function() { return /* binding */ Transition; }, 15072/* harmony export */ "TransitionGroup": function() { return /* binding */ TransitionGroup; }, 15073/* harmony export */ "VueElement": function() { return /* binding */ VueElement; }, 15074/* harmony export */ "callWithAsyncErrorHandling": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling; }, 15075/* harmony export */ "callWithErrorHandling": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.callWithErrorHandling; }, 15076/* harmony export */ "camelize": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.camelize; }, 15077/* harmony export */ "capitalize": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.capitalize; }, 15078/* harmony export */ "cloneVNode": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.cloneVNode; }, 15079/* harmony export */ "compatUtils": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.compatUtils; }, 15080/* harmony export */ "computed": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.computed; }, 15081/* harmony export */ "createApp": function() { return /* binding */ createApp; }, 15082/* harmony export */ "createBlock": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createBlock; }, 15083/* harmony export */ "createCommentVNode": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode; }, 15084/* harmony export */ "createElementBlock": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createElementBlock; }, 15085/* harmony export */ "createElementVNode": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createElementVNode; }, 15086/* harmony export */ "createHydrationRenderer": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer; }, 15087/* harmony export */ "createPropsRestProxy": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createPropsRestProxy; }, 15088/* harmony export */ "createRenderer": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createRenderer; }, 15089/* harmony export */ "createSSRApp": function() { return /* binding */ createSSRApp; }, 15090/* harmony export */ "createSlots": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createSlots; }, 15091/* harmony export */ "createStaticVNode": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode; }, 15092/* harmony export */ "createTextVNode": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createTextVNode; }, 15093/* harmony export */ "createVNode": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createVNode; }, 15094/* harmony export */ "customRef": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.customRef; }, 15095/* harmony export */ "defineAsyncComponent": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineAsyncComponent; }, 15096/* harmony export */ "defineComponent": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineComponent; }, 15097/* harmony export */ "defineCustomElement": function() { return /* binding */ defineCustomElement; }, 15098/* harmony export */ "defineEmits": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineEmits; }, 15099/* harmony export */ "defineExpose": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineExpose; }, 15100/* harmony export */ "defineProps": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineProps; }, 15101/* harmony export */ "defineSSRCustomElement": function() { return /* binding */ defineSSRCustomElement; }, 15102/* harmony export */ "devtools": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.devtools; }, 15103/* harmony export */ "effect": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.effect; }, 15104/* harmony export */ "effectScope": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.effectScope; }, 15105/* harmony export */ "getCurrentInstance": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance; }, 15106/* harmony export */ "getCurrentScope": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope; }, 15107/* harmony export */ "getTransitionRawChildren": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren; }, 15108/* harmony export */ "guardReactiveProps": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.guardReactiveProps; }, 15109/* harmony export */ "h": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.h; }, 15110/* harmony export */ "handleError": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.handleError; }, 15111/* harmony export */ "hydrate": function() { return /* binding */ hydrate; }, 15112/* harmony export */ "initCustomFormatter": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.initCustomFormatter; }, 15113/* harmony export */ "initDirectivesForSSR": function() { return /* binding */ initDirectivesForSSR; }, 15114/* harmony export */ "inject": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.inject; }, 15115/* harmony export */ "isMemoSame": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isMemoSame; }, 15116/* harmony export */ "isProxy": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isProxy; }, 15117/* harmony export */ "isReactive": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isReactive; }, 15118/* harmony export */ "isReadonly": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isReadonly; }, 15119/* harmony export */ "isRef": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isRef; }, 15120/* harmony export */ "isRuntimeOnly": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly; }, 15121/* harmony export */ "isShallow": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isShallow; }, 15122/* harmony export */ "isVNode": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isVNode; }, 15123/* harmony export */ "markRaw": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.markRaw; }, 15124/* harmony export */ "mergeDefaults": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.mergeDefaults; }, 15125/* harmony export */ "mergeProps": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.mergeProps; }, 15126/* harmony export */ "nextTick": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.nextTick; }, 15127/* harmony export */ "normalizeClass": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.normalizeClass; }, 15128/* harmony export */ "normalizeProps": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.normalizeProps; }, 15129/* harmony export */ "normalizeStyle": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle; }, 15130/* harmony export */ "onActivated": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onActivated; }, 15131/* harmony export */ "onBeforeMount": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount; }, 15132/* harmony export */ "onBeforeUnmount": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount; }, 15133/* harmony export */ "onBeforeUpdate": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeUpdate; }, 15134/* harmony export */ "onDeactivated": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onDeactivated; }, 15135/* harmony export */ "onErrorCaptured": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onErrorCaptured; }, 15136/* harmony export */ "onMounted": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onMounted; }, 15137/* harmony export */ "onRenderTracked": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onRenderTracked; }, 15138/* harmony export */ "onRenderTriggered": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onRenderTriggered; }, 15139/* harmony export */ "onScopeDispose": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose; }, 15140/* harmony export */ "onServerPrefetch": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onServerPrefetch; }, 15141/* harmony export */ "onUnmounted": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUnmounted; }, 15142/* harmony export */ "onUpdated": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUpdated; }, 15143/* harmony export */ "openBlock": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.openBlock; }, 15144/* harmony export */ "popScopeId": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.popScopeId; }, 15145/* harmony export */ "provide": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.provide; }, 15146/* harmony export */ "proxyRefs": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.proxyRefs; }, 15147/* harmony export */ "pushScopeId": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.pushScopeId; }, 15148/* harmony export */ "queuePostFlushCb": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.queuePostFlushCb; }, 15149/* harmony export */ "reactive": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.reactive; }, 15150/* harmony export */ "readonly": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.readonly; }, 15151/* harmony export */ "ref": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ref; }, 15152/* harmony export */ "registerRuntimeCompiler": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeCompiler; }, 15153/* harmony export */ "render": function() { return /* binding */ render; }, 15154/* harmony export */ "renderList": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.renderList; }, 15155/* harmony export */ "renderSlot": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.renderSlot; }, 15156/* harmony export */ "resolveComponent": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveComponent; }, 15157/* harmony export */ "resolveDirective": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveDirective; }, 15158/* harmony export */ "resolveDynamicComponent": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent; }, 15159/* harmony export */ "resolveFilter": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveFilter; }, 15160/* harmony export */ "resolveTransitionHooks": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks; }, 15161/* harmony export */ "setBlockTracking": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setBlockTracking; }, 15162/* harmony export */ "setDevtoolsHook": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setDevtoolsHook; }, 15163/* harmony export */ "setTransitionHooks": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks; }, 15164/* harmony export */ "shallowReactive": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.shallowReactive; }, 15165/* harmony export */ "shallowReadonly": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly; }, 15166/* harmony export */ "shallowRef": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.shallowRef; }, 15167/* harmony export */ "ssrContextKey": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ssrContextKey; }, 15168/* harmony export */ "ssrUtils": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ssrUtils; }, 15169/* harmony export */ "stop": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.stop; }, 15170/* harmony export */ "toDisplayString": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toDisplayString; }, 15171/* harmony export */ "toHandlerKey": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey; }, 15172/* harmony export */ "toHandlers": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toHandlers; }, 15173/* harmony export */ "toRaw": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toRaw; }, 15174/* harmony export */ "toRef": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toRef; }, 15175/* harmony export */ "toRefs": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toRefs; }, 15176/* harmony export */ "transformVNodeArgs": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.transformVNodeArgs; }, 15177/* harmony export */ "triggerRef": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.triggerRef; }, 15178/* harmony export */ "unref": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.unref; }, 15179/* harmony export */ "useAttrs": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useAttrs; }, 15180/* harmony export */ "useCssModule": function() { return /* binding */ useCssModule; }, 15181/* harmony export */ "useCssVars": function() { return /* binding */ useCssVars; }, 15182/* harmony export */ "useSSRContext": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useSSRContext; }, 15183/* harmony export */ "useSlots": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useSlots; }, 15184/* harmony export */ "useTransitionState": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useTransitionState; }, 15185/* harmony export */ "vModelCheckbox": function() { return /* binding */ vModelCheckbox; }, 15186/* harmony export */ "vModelDynamic": function() { return /* binding */ vModelDynamic; }, 15187/* harmony export */ "vModelRadio": function() { return /* binding */ vModelRadio; }, 15188/* harmony export */ "vModelSelect": function() { return /* binding */ vModelSelect; }, 15189/* harmony export */ "vModelText": function() { return /* binding */ vModelText; }, 15190/* harmony export */ "vShow": function() { return /* binding */ vShow; }, 15191/* harmony export */ "version": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.version; }, 15192/* harmony export */ "warn": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn; }, 15193/* harmony export */ "watch": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watch; }, 15194/* harmony export */ "watchEffect": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchEffect; }, 15195/* harmony export */ "watchPostEffect": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchPostEffect; }, 15196/* harmony export */ "watchSyncEffect": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchSyncEffect; }, 15197/* harmony export */ "withAsyncContext": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withAsyncContext; }, 15198/* harmony export */ "withCtx": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withCtx; }, 15199/* harmony export */ "withDefaults": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withDefaults; }, 15200/* harmony export */ "withDirectives": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withDirectives; }, 15201/* harmony export */ "withKeys": function() { return /* binding */ withKeys; }, 15202/* harmony export */ "withMemo": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withMemo; }, 15203/* harmony export */ "withModifiers": function() { return /* binding */ withModifiers; }, 15204/* harmony export */ "withScopeId": function() { return /* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withScopeId; } 15205/* harmony export */ }); 15206/* 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"); 15207/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 15208/* harmony import */ var _vue_runtime_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @vue/runtime-core */ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js"); 15209 15210 15211 15212 15213const svgNS = 'http://www.w3.org/2000/svg'; 15214const doc = (typeof document !== 'undefined' ? document : null); 15215const templateContainer = doc && /*#__PURE__*/ doc.createElement('template'); 15216const nodeOps = { 15217 insert: (child, parent, anchor) => { 15218 parent.insertBefore(child, anchor || null); 15219 }, 15220 remove: child => { 15221 const parent = child.parentNode; 15222 if (parent) { 15223 parent.removeChild(child); 15224 } 15225 }, 15226 createElement: (tag, isSVG, is, props) => { 15227 const el = isSVG 15228 ? doc.createElementNS(svgNS, tag) 15229 : doc.createElement(tag, is ? { is } : undefined); 15230 if (tag === 'select' && props && props.multiple != null) { 15231 el.setAttribute('multiple', props.multiple); 15232 } 15233 return el; 15234 }, 15235 createText: text => doc.createTextNode(text), 15236 createComment: text => doc.createComment(text), 15237 setText: (node, text) => { 15238 node.nodeValue = text; 15239 }, 15240 setElementText: (el, text) => { 15241 el.textContent = text; 15242 }, 15243 parentNode: node => node.parentNode, 15244 nextSibling: node => node.nextSibling, 15245 querySelector: selector => doc.querySelector(selector), 15246 setScopeId(el, id) { 15247 el.setAttribute(id, ''); 15248 }, 15249 // __UNSAFE__ 15250 // Reason: innerHTML. 15251 // Static content here can only come from compiled templates. 15252 // As long as the user only uses trusted templates, this is safe. 15253 insertStaticContent(content, parent, anchor, isSVG, start, end) { 15254 // <parent> before | first ... last | anchor </parent> 15255 const before = anchor ? anchor.previousSibling : parent.lastChild; 15256 // #5308 can only take cached path if: 15257 // - has a single root node 15258 // - nextSibling info is still available 15259 if (start && (start === end || start.nextSibling)) { 15260 // cached 15261 while (true) { 15262 parent.insertBefore(start.cloneNode(true), anchor); 15263 if (start === end || !(start = start.nextSibling)) 15264 break; 15265 } 15266 } 15267 else { 15268 // fresh insert 15269 templateContainer.innerHTML = isSVG ? `<svg>${content}</svg>` : content; 15270 const template = templateContainer.content; 15271 if (isSVG) { 15272 // remove outer svg wrapper 15273 const wrapper = template.firstChild; 15274 while (wrapper.firstChild) { 15275 template.appendChild(wrapper.firstChild); 15276 } 15277 template.removeChild(wrapper); 15278 } 15279 parent.insertBefore(template, anchor); 15280 } 15281 return [ 15282 // first 15283 before ? before.nextSibling : parent.firstChild, 15284 // last 15285 anchor ? anchor.previousSibling : parent.lastChild 15286 ]; 15287 } 15288}; 15289 15290// compiler should normalize class + :class bindings on the same element 15291// into a single binding ['staticClass', dynamic] 15292function patchClass(el, value, isSVG) { 15293 // directly setting className should be faster than setAttribute in theory 15294 // if this is an element during a transition, take the temporary transition 15295 // classes into account. 15296 const transitionClasses = el._vtc; 15297 if (transitionClasses) { 15298 value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(' '); 15299 } 15300 if (value == null) { 15301 el.removeAttribute('class'); 15302 } 15303 else if (isSVG) { 15304 el.setAttribute('class', value); 15305 } 15306 else { 15307 el.className = value; 15308 } 15309} 15310 15311function patchStyle(el, prev, next) { 15312 const style = el.style; 15313 const isCssString = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(next); 15314 if (next && !isCssString) { 15315 for (const key in next) { 15316 setStyle(style, key, next[key]); 15317 } 15318 if (prev && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(prev)) { 15319 for (const key in prev) { 15320 if (next[key] == null) { 15321 setStyle(style, key, ''); 15322 } 15323 } 15324 } 15325 } 15326 else { 15327 const currentDisplay = style.display; 15328 if (isCssString) { 15329 if (prev !== next) { 15330 style.cssText = next; 15331 } 15332 } 15333 else if (prev) { 15334 el.removeAttribute('style'); 15335 } 15336 // indicates that the `display` of the element is controlled by `v-show`, 15337 // so we always keep the current `display` value regardless of the `style` 15338 // value, thus handing over control to `v-show`. 15339 if ('_vod' in el) { 15340 style.display = currentDisplay; 15341 } 15342 } 15343} 15344const semicolonRE = /[^\\];\s*$/; 15345const importantRE = /\s*!important$/; 15346function setStyle(style, name, val) { 15347 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(val)) { 15348 val.forEach(v => setStyle(style, name, v)); 15349 } 15350 else { 15351 if (val == null) 15352 val = ''; 15353 if ((true)) { 15354 if (semicolonRE.test(val)) { 15355 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Unexpected semicolon at the end of '${name}' style value: '${val}'`); 15356 } 15357 } 15358 if (name.startsWith('--')) { 15359 // custom property definition 15360 style.setProperty(name, val); 15361 } 15362 else { 15363 const prefixed = autoPrefix(style, name); 15364 if (importantRE.test(val)) { 15365 // !important 15366 style.setProperty((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(prefixed), val.replace(importantRE, ''), 'important'); 15367 } 15368 else { 15369 style[prefixed] = val; 15370 } 15371 } 15372 } 15373} 15374const prefixes = ['Webkit', 'Moz', 'ms']; 15375const prefixCache = {}; 15376function autoPrefix(style, rawName) { 15377 const cached = prefixCache[rawName]; 15378 if (cached) { 15379 return cached; 15380 } 15381 let name = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(rawName); 15382 if (name !== 'filter' && name in style) { 15383 return (prefixCache[rawName] = name); 15384 } 15385 name = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)(name); 15386 for (let i = 0; i < prefixes.length; i++) { 15387 const prefixed = prefixes[i] + name; 15388 if (prefixed in style) { 15389 return (prefixCache[rawName] = prefixed); 15390 } 15391 } 15392 return rawName; 15393} 15394 15395const xlinkNS = 'http://www.w3.org/1999/xlink'; 15396function patchAttr(el, key, value, isSVG, instance) { 15397 if (isSVG && key.startsWith('xlink:')) { 15398 if (value == null) { 15399 el.removeAttributeNS(xlinkNS, key.slice(6, key.length)); 15400 } 15401 else { 15402 el.setAttributeNS(xlinkNS, key, value); 15403 } 15404 } 15405 else { 15406 // note we are only checking boolean attributes that don't have a 15407 // corresponding dom prop of the same name here. 15408 const isBoolean = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSpecialBooleanAttr)(key); 15409 if (value == null || (isBoolean && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.includeBooleanAttr)(value))) { 15410 el.removeAttribute(key); 15411 } 15412 else { 15413 el.setAttribute(key, isBoolean ? '' : value); 15414 } 15415 } 15416} 15417 15418// __UNSAFE__ 15419// functions. The user is responsible for using them with only trusted content. 15420function patchDOMProp(el, key, value, 15421// the following args are passed only due to potential innerHTML/textContent 15422// overriding existing VNodes, in which case the old tree must be properly 15423// unmounted. 15424prevChildren, parentComponent, parentSuspense, unmountChildren) { 15425 if (key === 'innerHTML' || key === 'textContent') { 15426 if (prevChildren) { 15427 unmountChildren(prevChildren, parentComponent, parentSuspense); 15428 } 15429 el[key] = value == null ? '' : value; 15430 return; 15431 } 15432 if (key === 'value' && 15433 el.tagName !== 'PROGRESS' && 15434 // custom elements may use _value internally 15435 !el.tagName.includes('-')) { 15436 // store value as _value as well since 15437 // non-string values will be stringified. 15438 el._value = value; 15439 const newValue = value == null ? '' : value; 15440 if (el.value !== newValue || 15441 // #4956: always set for OPTION elements because its value falls back to 15442 // textContent if no value attribute is present. And setting .value for 15443 // OPTION has no side effect 15444 el.tagName === 'OPTION') { 15445 el.value = newValue; 15446 } 15447 if (value == null) { 15448 el.removeAttribute(key); 15449 } 15450 return; 15451 } 15452 let needRemove = false; 15453 if (value === '' || value == null) { 15454 const type = typeof el[key]; 15455 if (type === 'boolean') { 15456 // e.g. <select multiple> compiles to { multiple: '' } 15457 value = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.includeBooleanAttr)(value); 15458 } 15459 else if (value == null && type === 'string') { 15460 // e.g. <div :id="null"> 15461 value = ''; 15462 needRemove = true; 15463 } 15464 else if (type === 'number') { 15465 // e.g. <img :width="null"> 15466 value = 0; 15467 needRemove = true; 15468 } 15469 } 15470 // some properties perform value validation and throw, 15471 // some properties has getter, no setter, will error in 'use strict' 15472 // eg. <select :type="null"></select> <select :willValidate="null"></select> 15473 try { 15474 el[key] = value; 15475 } 15476 catch (e) { 15477 // do not warn if value is auto-coerced from nullish values 15478 if (( true) && !needRemove) { 15479 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Failed setting prop "${key}" on <${el.tagName.toLowerCase()}>: ` + 15480 `value ${value} is invalid.`, e); 15481 } 15482 } 15483 needRemove && el.removeAttribute(key); 15484} 15485 15486function addEventListener(el, event, handler, options) { 15487 el.addEventListener(event, handler, options); 15488} 15489function removeEventListener(el, event, handler, options) { 15490 el.removeEventListener(event, handler, options); 15491} 15492function patchEvent(el, rawName, prevValue, nextValue, instance = null) { 15493 // vei = vue event invokers 15494 const invokers = el._vei || (el._vei = {}); 15495 const existingInvoker = invokers[rawName]; 15496 if (nextValue && existingInvoker) { 15497 // patch 15498 existingInvoker.value = nextValue; 15499 } 15500 else { 15501 const [name, options] = parseName(rawName); 15502 if (nextValue) { 15503 // add 15504 const invoker = (invokers[rawName] = createInvoker(nextValue, instance)); 15505 addEventListener(el, name, invoker, options); 15506 } 15507 else if (existingInvoker) { 15508 // remove 15509 removeEventListener(el, name, existingInvoker, options); 15510 invokers[rawName] = undefined; 15511 } 15512 } 15513} 15514const optionsModifierRE = /(?:Once|Passive|Capture)$/; 15515function parseName(name) { 15516 let options; 15517 if (optionsModifierRE.test(name)) { 15518 options = {}; 15519 let m; 15520 while ((m = name.match(optionsModifierRE))) { 15521 name = name.slice(0, name.length - m[0].length); 15522 options[m[0].toLowerCase()] = true; 15523 } 15524 } 15525 const event = name[2] === ':' ? name.slice(3) : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(name.slice(2)); 15526 return [event, options]; 15527} 15528// To avoid the overhead of repeatedly calling Date.now(), we cache 15529// and use the same timestamp for all event listeners attached in the same tick. 15530let cachedNow = 0; 15531const p = /*#__PURE__*/ Promise.resolve(); 15532const getNow = () => cachedNow || (p.then(() => (cachedNow = 0)), (cachedNow = Date.now())); 15533function createInvoker(initialValue, instance) { 15534 const invoker = (e) => { 15535 // async edge case vuejs/vue#6566 15536 // inner click event triggers patch, event handler 15537 // attached to outer element during patch, and triggered again. This 15538 // happens because browsers fire microtask ticks between event propagation. 15539 // this no longer happens for templates in Vue 3, but could still be 15540 // theoretically possible for hand-written render functions. 15541 // the solution: we save the timestamp when a handler is attached, 15542 // and also attach the timestamp to any event that was handled by vue 15543 // for the first time (to avoid inconsistent event timestamp implementations 15544 // or events fired from iframes, e.g. #2513) 15545 // The handler would only fire if the event passed to it was fired 15546 // AFTER it was attached. 15547 if (!e._vts) { 15548 e._vts = Date.now(); 15549 } 15550 else if (e._vts <= invoker.attached) { 15551 return; 15552 } 15553 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling)(patchStopImmediatePropagation(e, invoker.value), instance, 5 /* ErrorCodes.NATIVE_EVENT_HANDLER */, [e]); 15554 }; 15555 invoker.value = initialValue; 15556 invoker.attached = getNow(); 15557 return invoker; 15558} 15559function patchStopImmediatePropagation(e, value) { 15560 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) { 15561 const originalStop = e.stopImmediatePropagation; 15562 e.stopImmediatePropagation = () => { 15563 originalStop.call(e); 15564 e._stopped = true; 15565 }; 15566 return value.map(fn => (e) => !e._stopped && fn && fn(e)); 15567 } 15568 else { 15569 return value; 15570 } 15571} 15572 15573const nativeOnRE = /^on[a-z]/; 15574const patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => { 15575 if (key === 'class') { 15576 patchClass(el, nextValue, isSVG); 15577 } 15578 else if (key === 'style') { 15579 patchStyle(el, prevValue, nextValue); 15580 } 15581 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) { 15582 // ignore v-model listeners 15583 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)(key)) { 15584 patchEvent(el, key, prevValue, nextValue, parentComponent); 15585 } 15586 } 15587 else if (key[0] === '.' 15588 ? ((key = key.slice(1)), true) 15589 : key[0] === '^' 15590 ? ((key = key.slice(1)), false) 15591 : shouldSetAsProp(el, key, nextValue, isSVG)) { 15592 patchDOMProp(el, key, nextValue, prevChildren, parentComponent, parentSuspense, unmountChildren); 15593 } 15594 else { 15595 // special case for <input v-model type="checkbox"> with 15596 // :true-value & :false-value 15597 // store value as dom properties since non-string values will be 15598 // stringified. 15599 if (key === 'true-value') { 15600 el._trueValue = nextValue; 15601 } 15602 else if (key === 'false-value') { 15603 el._falseValue = nextValue; 15604 } 15605 patchAttr(el, key, nextValue, isSVG); 15606 } 15607}; 15608function shouldSetAsProp(el, key, value, isSVG) { 15609 if (isSVG) { 15610 // most keys must be set as attribute on svg elements to work 15611 // ...except innerHTML & textContent 15612 if (key === 'innerHTML' || key === 'textContent') { 15613 return true; 15614 } 15615 // or native onclick with function values 15616 if (key in el && nativeOnRE.test(key) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) { 15617 return true; 15618 } 15619 return false; 15620 } 15621 // these are enumerated attrs, however their corresponding DOM properties 15622 // are actually booleans - this leads to setting it with a string "false" 15623 // value leading it to be coerced to `true`, so we need to always treat 15624 // them as attributes. 15625 // Note that `contentEditable` doesn't have this problem: its DOM 15626 // property is also enumerated string values. 15627 if (key === 'spellcheck' || key === 'draggable' || key === 'translate') { 15628 return false; 15629 } 15630 // #1787, #2840 form property on form elements is readonly and must be set as 15631 // attribute. 15632 if (key === 'form') { 15633 return false; 15634 } 15635 // #1526 <input list> must be set as attribute 15636 if (key === 'list' && el.tagName === 'INPUT') { 15637 return false; 15638 } 15639 // #2766 <textarea type> must be set as attribute 15640 if (key === 'type' && el.tagName === 'TEXTAREA') { 15641 return false; 15642 } 15643 // native onclick with string value, must be set as attribute 15644 if (nativeOnRE.test(key) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(value)) { 15645 return false; 15646 } 15647 return key in el; 15648} 15649 15650function defineCustomElement(options, hydrate) { 15651 const Comp = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineComponent)(options); 15652 class VueCustomElement extends VueElement { 15653 constructor(initialProps) { 15654 super(Comp, initialProps, hydrate); 15655 } 15656 } 15657 VueCustomElement.def = Comp; 15658 return VueCustomElement; 15659} 15660const defineSSRCustomElement = ((options) => { 15661 // @ts-ignore 15662 return defineCustomElement(options, hydrate); 15663}); 15664const BaseClass = (typeof HTMLElement !== 'undefined' ? HTMLElement : class { 15665}); 15666class VueElement extends BaseClass { 15667 constructor(_def, _props = {}, hydrate) { 15668 super(); 15669 this._def = _def; 15670 this._props = _props; 15671 /** 15672 * @internal 15673 */ 15674 this._instance = null; 15675 this._connected = false; 15676 this._resolved = false; 15677 this._numberProps = null; 15678 if (this.shadowRoot && hydrate) { 15679 hydrate(this._createVNode(), this.shadowRoot); 15680 } 15681 else { 15682 if (( true) && this.shadowRoot) { 15683 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Custom element has pre-rendered declarative shadow root but is not ` + 15684 `defined as hydratable. Use \`defineSSRCustomElement\`.`); 15685 } 15686 this.attachShadow({ mode: 'open' }); 15687 if (!this._def.__asyncLoader) { 15688 // for sync component defs we can immediately resolve props 15689 this._resolveProps(this._def); 15690 } 15691 } 15692 } 15693 connectedCallback() { 15694 this._connected = true; 15695 if (!this._instance) { 15696 if (this._resolved) { 15697 this._update(); 15698 } 15699 else { 15700 this._resolveDef(); 15701 } 15702 } 15703 } 15704 disconnectedCallback() { 15705 this._connected = false; 15706 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => { 15707 if (!this._connected) { 15708 render(null, this.shadowRoot); 15709 this._instance = null; 15710 } 15711 }); 15712 } 15713 /** 15714 * resolve inner component definition (handle possible async component) 15715 */ 15716 _resolveDef() { 15717 this._resolved = true; 15718 // set initial attrs 15719 for (let i = 0; i < this.attributes.length; i++) { 15720 this._setAttr(this.attributes[i].name); 15721 } 15722 // watch future attr changes 15723 new MutationObserver(mutations => { 15724 for (const m of mutations) { 15725 this._setAttr(m.attributeName); 15726 } 15727 }).observe(this, { attributes: true }); 15728 const resolve = (def, isAsync = false) => { 15729 const { props, styles } = def; 15730 // cast Number-type props set before resolve 15731 let numberProps; 15732 if (props && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(props)) { 15733 for (const key in props) { 15734 const opt = props[key]; 15735 if (opt === Number || (opt && opt.type === Number)) { 15736 if (key in this._props) { 15737 this._props[key] = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(this._props[key]); 15738 } 15739 (numberProps || (numberProps = Object.create(null)))[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key)] = true; 15740 } 15741 } 15742 } 15743 this._numberProps = numberProps; 15744 if (isAsync) { 15745 // defining getter/setters on prototype 15746 // for sync defs, this already happened in the constructor 15747 this._resolveProps(def); 15748 } 15749 // apply CSS 15750 this._applyStyles(styles); 15751 // initial render 15752 this._update(); 15753 }; 15754 const asyncDef = this._def.__asyncLoader; 15755 if (asyncDef) { 15756 asyncDef().then(def => resolve(def, true)); 15757 } 15758 else { 15759 resolve(this._def); 15760 } 15761 } 15762 _resolveProps(def) { 15763 const { props } = def; 15764 const declaredPropKeys = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(props) ? props : Object.keys(props || {}); 15765 // check if there are props set pre-upgrade or connect 15766 for (const key of Object.keys(this)) { 15767 if (key[0] !== '_' && declaredPropKeys.includes(key)) { 15768 this._setProp(key, this[key], true, false); 15769 } 15770 } 15771 // defining getter/setters on prototype 15772 for (const key of declaredPropKeys.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)) { 15773 Object.defineProperty(this, key, { 15774 get() { 15775 return this._getProp(key); 15776 }, 15777 set(val) { 15778 this._setProp(key, val); 15779 } 15780 }); 15781 } 15782 } 15783 _setAttr(key) { 15784 let value = this.getAttribute(key); 15785 const camelKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key); 15786 if (this._numberProps && this._numberProps[camelKey]) { 15787 value = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(value); 15788 } 15789 this._setProp(camelKey, value, false); 15790 } 15791 /** 15792 * @internal 15793 */ 15794 _getProp(key) { 15795 return this._props[key]; 15796 } 15797 /** 15798 * @internal 15799 */ 15800 _setProp(key, val, shouldReflect = true, shouldUpdate = true) { 15801 if (val !== this._props[key]) { 15802 this._props[key] = val; 15803 if (shouldUpdate && this._instance) { 15804 this._update(); 15805 } 15806 // reflect 15807 if (shouldReflect) { 15808 if (val === true) { 15809 this.setAttribute((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key), ''); 15810 } 15811 else if (typeof val === 'string' || typeof val === 'number') { 15812 this.setAttribute((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key), val + ''); 15813 } 15814 else if (!val) { 15815 this.removeAttribute((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key)); 15816 } 15817 } 15818 } 15819 } 15820 _update() { 15821 render(this._createVNode(), this.shadowRoot); 15822 } 15823 _createVNode() { 15824 const vnode = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createVNode)(this._def, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, this._props)); 15825 if (!this._instance) { 15826 vnode.ce = instance => { 15827 this._instance = instance; 15828 instance.isCE = true; 15829 // HMR 15830 if ((true)) { 15831 instance.ceReload = newStyles => { 15832 // always reset styles 15833 if (this._styles) { 15834 this._styles.forEach(s => this.shadowRoot.removeChild(s)); 15835 this._styles.length = 0; 15836 } 15837 this._applyStyles(newStyles); 15838 this._instance = null; 15839 this._update(); 15840 }; 15841 } 15842 const dispatch = (event, args) => { 15843 this.dispatchEvent(new CustomEvent(event, { 15844 detail: args 15845 })); 15846 }; 15847 // intercept emit 15848 instance.emit = (event, ...args) => { 15849 // dispatch both the raw and hyphenated versions of an event 15850 // to match Vue behavior 15851 dispatch(event, args); 15852 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event) !== event) { 15853 dispatch((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event), args); 15854 } 15855 }; 15856 // locate nearest Vue custom element parent for provide/inject 15857 let parent = this; 15858 while ((parent = 15859 parent && (parent.parentNode || parent.host))) { 15860 if (parent instanceof VueElement) { 15861 instance.parent = parent._instance; 15862 instance.provides = parent._instance.provides; 15863 break; 15864 } 15865 } 15866 }; 15867 } 15868 return vnode; 15869 } 15870 _applyStyles(styles) { 15871 if (styles) { 15872 styles.forEach(css => { 15873 const s = document.createElement('style'); 15874 s.textContent = css; 15875 this.shadowRoot.appendChild(s); 15876 // record for HMR 15877 if ((true)) { 15878 (this._styles || (this._styles = [])).push(s); 15879 } 15880 }); 15881 } 15882 } 15883} 15884 15885function useCssModule(name = '$style') { 15886 /* istanbul ignore else */ 15887 { 15888 const instance = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)(); 15889 if (!instance) { 15890 ( true) && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`useCssModule must be called inside setup()`); 15891 return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 15892 } 15893 const modules = instance.type.__cssModules; 15894 if (!modules) { 15895 ( true) && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Current instance does not have CSS modules injected.`); 15896 return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 15897 } 15898 const mod = modules[name]; 15899 if (!mod) { 15900 ( true) && 15901 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Current instance does not have CSS module named "${name}".`); 15902 return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ; 15903 } 15904 return mod; 15905 } 15906} 15907 15908/** 15909 * Runtime helper for SFC's CSS variable injection feature. 15910 * @private 15911 */ 15912function useCssVars(getter) { 15913 const instance = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)(); 15914 /* istanbul ignore next */ 15915 if (!instance) { 15916 ( true) && 15917 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`useCssVars is called without current active component instance.`); 15918 return; 15919 } 15920 const updateTeleports = (instance.ut = (vars = getter(instance.proxy)) => { 15921 Array.from(document.querySelectorAll(`[data-v-owner="${instance.uid}"]`)).forEach(node => setVarsOnNode(node, vars)); 15922 }); 15923 const setVars = () => { 15924 const vars = getter(instance.proxy); 15925 setVarsOnVNode(instance.subTree, vars); 15926 updateTeleports(vars); 15927 }; 15928 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchPostEffect)(setVars); 15929 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => { 15930 const ob = new MutationObserver(setVars); 15931 ob.observe(instance.subTree.el.parentNode, { childList: true }); 15932 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => ob.disconnect()); 15933 }); 15934} 15935function setVarsOnVNode(vnode, vars) { 15936 if (vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */) { 15937 const suspense = vnode.suspense; 15938 vnode = suspense.activeBranch; 15939 if (suspense.pendingBranch && !suspense.isHydrating) { 15940 suspense.effects.push(() => { 15941 setVarsOnVNode(suspense.activeBranch, vars); 15942 }); 15943 } 15944 } 15945 // drill down HOCs until it's a non-component vnode 15946 while (vnode.component) { 15947 vnode = vnode.component.subTree; 15948 } 15949 if (vnode.shapeFlag & 1 /* ShapeFlags.ELEMENT */ && vnode.el) { 15950 setVarsOnNode(vnode.el, vars); 15951 } 15952 else if (vnode.type === _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Fragment) { 15953 vnode.children.forEach(c => setVarsOnVNode(c, vars)); 15954 } 15955 else if (vnode.type === _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Static) { 15956 let { el, anchor } = vnode; 15957 while (el) { 15958 setVarsOnNode(el, vars); 15959 if (el === anchor) 15960 break; 15961 el = el.nextSibling; 15962 } 15963 } 15964} 15965function setVarsOnNode(el, vars) { 15966 if (el.nodeType === 1) { 15967 const style = el.style; 15968 for (const key in vars) { 15969 style.setProperty(`--${key}`, vars[key]); 15970 } 15971 } 15972} 15973 15974const TRANSITION = 'transition'; 15975const ANIMATION = 'animation'; 15976// DOM Transition is a higher-order-component based on the platform-agnostic 15977// base Transition component, with DOM-specific logic. 15978const Transition = (props, { slots }) => (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.h)(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransition, resolveTransitionProps(props), slots); 15979Transition.displayName = 'Transition'; 15980const DOMTransitionPropsValidators = { 15981 name: String, 15982 type: String, 15983 css: { 15984 type: Boolean, 15985 default: true 15986 }, 15987 duration: [String, Number, Object], 15988 enterFromClass: String, 15989 enterActiveClass: String, 15990 enterToClass: String, 15991 appearFromClass: String, 15992 appearActiveClass: String, 15993 appearToClass: String, 15994 leaveFromClass: String, 15995 leaveActiveClass: String, 15996 leaveToClass: String 15997}; 15998const TransitionPropsValidators = (Transition.props = 15999 /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransition.props, DOMTransitionPropsValidators)); 16000/** 16001 * #3227 Incoming hooks may be merged into arrays when wrapping Transition 16002 * with custom HOCs. 16003 */ 16004const callHook = (hook, args = []) => { 16005 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook)) { 16006 hook.forEach(h => h(...args)); 16007 } 16008 else if (hook) { 16009 hook(...args); 16010 } 16011}; 16012/** 16013 * Check if a hook expects a callback (2nd arg), which means the user 16014 * intends to explicitly control the end of the transition. 16015 */ 16016const hasExplicitCallback = (hook) => { 16017 return hook 16018 ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook) 16019 ? hook.some(h => h.length > 1) 16020 : hook.length > 1 16021 : false; 16022}; 16023function resolveTransitionProps(rawProps) { 16024 const baseProps = {}; 16025 for (const key in rawProps) { 16026 if (!(key in DOMTransitionPropsValidators)) { 16027 baseProps[key] = rawProps[key]; 16028 } 16029 } 16030 if (rawProps.css === false) { 16031 return baseProps; 16032 } 16033 const { name = 'v', type, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps; 16034 const durations = normalizeDuration(duration); 16035 const enterDuration = durations && durations[0]; 16036 const leaveDuration = durations && durations[1]; 16037 const { onBeforeEnter, onEnter, onEnterCancelled, onLeave, onLeaveCancelled, onBeforeAppear = onBeforeEnter, onAppear = onEnter, onAppearCancelled = onEnterCancelled } = baseProps; 16038 const finishEnter = (el, isAppear, done) => { 16039 removeTransitionClass(el, isAppear ? appearToClass : enterToClass); 16040 removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass); 16041 done && done(); 16042 }; 16043 const finishLeave = (el, done) => { 16044 el._isLeaving = false; 16045 removeTransitionClass(el, leaveFromClass); 16046 removeTransitionClass(el, leaveToClass); 16047 removeTransitionClass(el, leaveActiveClass); 16048 done && done(); 16049 }; 16050 const makeEnterHook = (isAppear) => { 16051 return (el, done) => { 16052 const hook = isAppear ? onAppear : onEnter; 16053 const resolve = () => finishEnter(el, isAppear, done); 16054 callHook(hook, [el, resolve]); 16055 nextFrame(() => { 16056 removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass); 16057 addTransitionClass(el, isAppear ? appearToClass : enterToClass); 16058 if (!hasExplicitCallback(hook)) { 16059 whenTransitionEnds(el, type, enterDuration, resolve); 16060 } 16061 }); 16062 }; 16063 }; 16064 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(baseProps, { 16065 onBeforeEnter(el) { 16066 callHook(onBeforeEnter, [el]); 16067 addTransitionClass(el, enterFromClass); 16068 addTransitionClass(el, enterActiveClass); 16069 }, 16070 onBeforeAppear(el) { 16071 callHook(onBeforeAppear, [el]); 16072 addTransitionClass(el, appearFromClass); 16073 addTransitionClass(el, appearActiveClass); 16074 }, 16075 onEnter: makeEnterHook(false), 16076 onAppear: makeEnterHook(true), 16077 onLeave(el, done) { 16078 el._isLeaving = true; 16079 const resolve = () => finishLeave(el, done); 16080 addTransitionClass(el, leaveFromClass); 16081 // force reflow so *-leave-from classes immediately take effect (#2593) 16082 forceReflow(); 16083 addTransitionClass(el, leaveActiveClass); 16084 nextFrame(() => { 16085 if (!el._isLeaving) { 16086 // cancelled 16087 return; 16088 } 16089 removeTransitionClass(el, leaveFromClass); 16090 addTransitionClass(el, leaveToClass); 16091 if (!hasExplicitCallback(onLeave)) { 16092 whenTransitionEnds(el, type, leaveDuration, resolve); 16093 } 16094 }); 16095 callHook(onLeave, [el, resolve]); 16096 }, 16097 onEnterCancelled(el) { 16098 finishEnter(el, false); 16099 callHook(onEnterCancelled, [el]); 16100 }, 16101 onAppearCancelled(el) { 16102 finishEnter(el, true); 16103 callHook(onAppearCancelled, [el]); 16104 }, 16105 onLeaveCancelled(el) { 16106 finishLeave(el); 16107 callHook(onLeaveCancelled, [el]); 16108 } 16109 }); 16110} 16111function normalizeDuration(duration) { 16112 if (duration == null) { 16113 return null; 16114 } 16115 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(duration)) { 16116 return [NumberOf(duration.enter), NumberOf(duration.leave)]; 16117 } 16118 else { 16119 const n = NumberOf(duration); 16120 return [n, n]; 16121 } 16122} 16123function NumberOf(val) { 16124 const res = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(val); 16125 if ((true)) 16126 validateDuration(res); 16127 return res; 16128} 16129function validateDuration(val) { 16130 if (typeof val !== 'number') { 16131 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`<transition> explicit duration is not a valid number - ` + 16132 `got ${JSON.stringify(val)}.`); 16133 } 16134 else if (isNaN(val)) { 16135 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`<transition> explicit duration is NaN - ` + 16136 'the duration expression might be incorrect.'); 16137 } 16138} 16139function addTransitionClass(el, cls) { 16140 cls.split(/\s+/).forEach(c => c && el.classList.add(c)); 16141 (el._vtc || 16142 (el._vtc = new Set())).add(cls); 16143} 16144function removeTransitionClass(el, cls) { 16145 cls.split(/\s+/).forEach(c => c && el.classList.remove(c)); 16146 const { _vtc } = el; 16147 if (_vtc) { 16148 _vtc.delete(cls); 16149 if (!_vtc.size) { 16150 el._vtc = undefined; 16151 } 16152 } 16153} 16154function nextFrame(cb) { 16155 requestAnimationFrame(() => { 16156 requestAnimationFrame(cb); 16157 }); 16158} 16159let endId = 0; 16160function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) { 16161 const id = (el._endId = ++endId); 16162 const resolveIfNotStale = () => { 16163 if (id === el._endId) { 16164 resolve(); 16165 } 16166 }; 16167 if (explicitTimeout) { 16168 return setTimeout(resolveIfNotStale, explicitTimeout); 16169 } 16170 const { type, timeout, propCount } = getTransitionInfo(el, expectedType); 16171 if (!type) { 16172 return resolve(); 16173 } 16174 const endEvent = type + 'end'; 16175 let ended = 0; 16176 const end = () => { 16177 el.removeEventListener(endEvent, onEnd); 16178 resolveIfNotStale(); 16179 }; 16180 const onEnd = (e) => { 16181 if (e.target === el && ++ended >= propCount) { 16182 end(); 16183 } 16184 }; 16185 setTimeout(() => { 16186 if (ended < propCount) { 16187 end(); 16188 } 16189 }, timeout + 1); 16190 el.addEventListener(endEvent, onEnd); 16191} 16192function getTransitionInfo(el, expectedType) { 16193 const styles = window.getComputedStyle(el); 16194 // JSDOM may return undefined for transition properties 16195 const getStyleProperties = (key) => (styles[key] || '').split(', '); 16196 const transitionDelays = getStyleProperties(`${TRANSITION}Delay`); 16197 const transitionDurations = getStyleProperties(`${TRANSITION}Duration`); 16198 const transitionTimeout = getTimeout(transitionDelays, transitionDurations); 16199 const animationDelays = getStyleProperties(`${ANIMATION}Delay`); 16200 const animationDurations = getStyleProperties(`${ANIMATION}Duration`); 16201 const animationTimeout = getTimeout(animationDelays, animationDurations); 16202 let type = null; 16203 let timeout = 0; 16204 let propCount = 0; 16205 /* istanbul ignore if */ 16206 if (expectedType === TRANSITION) { 16207 if (transitionTimeout > 0) { 16208 type = TRANSITION; 16209 timeout = transitionTimeout; 16210 propCount = transitionDurations.length; 16211 } 16212 } 16213 else if (expectedType === ANIMATION) { 16214 if (animationTimeout > 0) { 16215 type = ANIMATION; 16216 timeout = animationTimeout; 16217 propCount = animationDurations.length; 16218 } 16219 } 16220 else { 16221 timeout = Math.max(transitionTimeout, animationTimeout); 16222 type = 16223 timeout > 0 16224 ? transitionTimeout > animationTimeout 16225 ? TRANSITION 16226 : ANIMATION 16227 : null; 16228 propCount = type 16229 ? type === TRANSITION 16230 ? transitionDurations.length 16231 : animationDurations.length 16232 : 0; 16233 } 16234 const hasTransform = type === TRANSITION && 16235 /\b(transform|all)(,|$)/.test(getStyleProperties(`${TRANSITION}Property`).toString()); 16236 return { 16237 type, 16238 timeout, 16239 propCount, 16240 hasTransform 16241 }; 16242} 16243function getTimeout(delays, durations) { 16244 while (delays.length < durations.length) { 16245 delays = delays.concat(delays); 16246 } 16247 return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i]))); 16248} 16249// Old versions of Chromium (below 61.0.3163.100) formats floating pointer 16250// numbers in a locale-dependent way, using a comma instead of a dot. 16251// If comma is not replaced with a dot, the input will be rounded down 16252// (i.e. acting as a floor function) causing unexpected behaviors 16253function toMs(s) { 16254 return Number(s.slice(0, -1).replace(',', '.')) * 1000; 16255} 16256// synchronously force layout to put elements into a certain state 16257function forceReflow() { 16258 return document.body.offsetHeight; 16259} 16260 16261const positionMap = new WeakMap(); 16262const newPositionMap = new WeakMap(); 16263const TransitionGroupImpl = { 16264 name: 'TransitionGroup', 16265 props: /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, TransitionPropsValidators, { 16266 tag: String, 16267 moveClass: String 16268 }), 16269 setup(props, { slots }) { 16270 const instance = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)(); 16271 const state = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useTransitionState)(); 16272 let prevChildren; 16273 let children; 16274 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUpdated)(() => { 16275 // children is guaranteed to exist after initial render 16276 if (!prevChildren.length) { 16277 return; 16278 } 16279 const moveClass = props.moveClass || `${props.name || 'v'}-move`; 16280 if (!hasCSSTransform(prevChildren[0].el, instance.vnode.el, moveClass)) { 16281 return; 16282 } 16283 // we divide the work into three loops to avoid mixing DOM reads and writes 16284 // in each iteration - which helps prevent layout thrashing. 16285 prevChildren.forEach(callPendingCbs); 16286 prevChildren.forEach(recordPosition); 16287 const movedChildren = prevChildren.filter(applyTranslation); 16288 // force reflow to put everything in position 16289 forceReflow(); 16290 movedChildren.forEach(c => { 16291 const el = c.el; 16292 const style = el.style; 16293 addTransitionClass(el, moveClass); 16294 style.transform = style.webkitTransform = style.transitionDuration = ''; 16295 const cb = (el._moveCb = (e) => { 16296 if (e && e.target !== el) { 16297 return; 16298 } 16299 if (!e || /transform$/.test(e.propertyName)) { 16300 el.removeEventListener('transitionend', cb); 16301 el._moveCb = null; 16302 removeTransitionClass(el, moveClass); 16303 } 16304 }); 16305 el.addEventListener('transitionend', cb); 16306 }); 16307 }); 16308 return () => { 16309 const rawProps = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_2__.toRaw)(props); 16310 const cssTransitionProps = resolveTransitionProps(rawProps); 16311 let tag = rawProps.tag || _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Fragment; 16312 prevChildren = children; 16313 children = slots.default ? (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren)(slots.default()) : []; 16314 for (let i = 0; i < children.length; i++) { 16315 const child = children[i]; 16316 if (child.key != null) { 16317 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks)(child, (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks)(child, cssTransitionProps, state, instance)); 16318 } 16319 else if ((true)) { 16320 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`<TransitionGroup> children must be keyed.`); 16321 } 16322 } 16323 if (prevChildren) { 16324 for (let i = 0; i < prevChildren.length; i++) { 16325 const child = prevChildren[i]; 16326 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks)(child, (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks)(child, cssTransitionProps, state, instance)); 16327 positionMap.set(child, child.el.getBoundingClientRect()); 16328 } 16329 } 16330 return (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createVNode)(tag, null, children); 16331 }; 16332 } 16333}; 16334const TransitionGroup = TransitionGroupImpl; 16335function callPendingCbs(c) { 16336 const el = c.el; 16337 if (el._moveCb) { 16338 el._moveCb(); 16339 } 16340 if (el._enterCb) { 16341 el._enterCb(); 16342 } 16343} 16344function recordPosition(c) { 16345 newPositionMap.set(c, c.el.getBoundingClientRect()); 16346} 16347function applyTranslation(c) { 16348 const oldPos = positionMap.get(c); 16349 const newPos = newPositionMap.get(c); 16350 const dx = oldPos.left - newPos.left; 16351 const dy = oldPos.top - newPos.top; 16352 if (dx || dy) { 16353 const s = c.el.style; 16354 s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`; 16355 s.transitionDuration = '0s'; 16356 return c; 16357 } 16358} 16359function hasCSSTransform(el, root, moveClass) { 16360 // Detect whether an element with the move class applied has 16361 // CSS transitions. Since the element may be inside an entering 16362 // transition at this very moment, we make a clone of it and remove 16363 // all other transition classes applied to ensure only the move class 16364 // is applied. 16365 const clone = el.cloneNode(); 16366 if (el._vtc) { 16367 el._vtc.forEach(cls => { 16368 cls.split(/\s+/).forEach(c => c && clone.classList.remove(c)); 16369 }); 16370 } 16371 moveClass.split(/\s+/).forEach(c => c && clone.classList.add(c)); 16372 clone.style.display = 'none'; 16373 const container = (root.nodeType === 1 ? root : root.parentNode); 16374 container.appendChild(clone); 16375 const { hasTransform } = getTransitionInfo(clone); 16376 container.removeChild(clone); 16377 return hasTransform; 16378} 16379 16380const getModelAssigner = (vnode) => { 16381 const fn = vnode.props['onUpdate:modelValue'] || 16382 (false ); 16383 return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(fn) ? value => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(fn, value) : fn; 16384}; 16385function onCompositionStart(e) { 16386 e.target.composing = true; 16387} 16388function onCompositionEnd(e) { 16389 const target = e.target; 16390 if (target.composing) { 16391 target.composing = false; 16392 target.dispatchEvent(new Event('input')); 16393 } 16394} 16395// We are exporting the v-model runtime directly as vnode hooks so that it can 16396// be tree-shaken in case v-model is never used. 16397const vModelText = { 16398 created(el, { modifiers: { lazy, trim, number } }, vnode) { 16399 el._assign = getModelAssigner(vnode); 16400 const castToNumber = number || (vnode.props && vnode.props.type === 'number'); 16401 addEventListener(el, lazy ? 'change' : 'input', e => { 16402 if (e.target.composing) 16403 return; 16404 let domValue = el.value; 16405 if (trim) { 16406 domValue = domValue.trim(); 16407 } 16408 if (castToNumber) { 16409 domValue = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(domValue); 16410 } 16411 el._assign(domValue); 16412 }); 16413 if (trim) { 16414 addEventListener(el, 'change', () => { 16415 el.value = el.value.trim(); 16416 }); 16417 } 16418 if (!lazy) { 16419 addEventListener(el, 'compositionstart', onCompositionStart); 16420 addEventListener(el, 'compositionend', onCompositionEnd); 16421 // Safari < 10.2 & UIWebView doesn't fire compositionend when 16422 // switching focus before confirming composition choice 16423 // this also fixes the issue where some browsers e.g. iOS Chrome 16424 // fires "change" instead of "input" on autocomplete. 16425 addEventListener(el, 'change', onCompositionEnd); 16426 } 16427 }, 16428 // set value on mounted so it's after min/max for type="range" 16429 mounted(el, { value }) { 16430 el.value = value == null ? '' : value; 16431 }, 16432 beforeUpdate(el, { value, modifiers: { lazy, trim, number } }, vnode) { 16433 el._assign = getModelAssigner(vnode); 16434 // avoid clearing unresolved text. #2302 16435 if (el.composing) 16436 return; 16437 if (document.activeElement === el && el.type !== 'range') { 16438 if (lazy) { 16439 return; 16440 } 16441 if (trim && el.value.trim() === value) { 16442 return; 16443 } 16444 if ((number || el.type === 'number') && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(el.value) === value) { 16445 return; 16446 } 16447 } 16448 const newValue = value == null ? '' : value; 16449 if (el.value !== newValue) { 16450 el.value = newValue; 16451 } 16452 } 16453}; 16454const vModelCheckbox = { 16455 // #4096 array checkboxes need to be deep traversed 16456 deep: true, 16457 created(el, _, vnode) { 16458 el._assign = getModelAssigner(vnode); 16459 addEventListener(el, 'change', () => { 16460 const modelValue = el._modelValue; 16461 const elementValue = getValue(el); 16462 const checked = el.checked; 16463 const assign = el._assign; 16464 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(modelValue)) { 16465 const index = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(modelValue, elementValue); 16466 const found = index !== -1; 16467 if (checked && !found) { 16468 assign(modelValue.concat(elementValue)); 16469 } 16470 else if (!checked && found) { 16471 const filtered = [...modelValue]; 16472 filtered.splice(index, 1); 16473 assign(filtered); 16474 } 16475 } 16476 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(modelValue)) { 16477 const cloned = new Set(modelValue); 16478 if (checked) { 16479 cloned.add(elementValue); 16480 } 16481 else { 16482 cloned.delete(elementValue); 16483 } 16484 assign(cloned); 16485 } 16486 else { 16487 assign(getCheckboxValue(el, checked)); 16488 } 16489 }); 16490 }, 16491 // set initial checked on mount to wait for true-value/false-value 16492 mounted: setChecked, 16493 beforeUpdate(el, binding, vnode) { 16494 el._assign = getModelAssigner(vnode); 16495 setChecked(el, binding, vnode); 16496 } 16497}; 16498function setChecked(el, { value, oldValue }, vnode) { 16499 el._modelValue = value; 16500 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) { 16501 el.checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(value, vnode.props.value) > -1; 16502 } 16503 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value)) { 16504 el.checked = value.has(vnode.props.value); 16505 } 16506 else if (value !== oldValue) { 16507 el.checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(value, getCheckboxValue(el, true)); 16508 } 16509} 16510const vModelRadio = { 16511 created(el, { value }, vnode) { 16512 el.checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(value, vnode.props.value); 16513 el._assign = getModelAssigner(vnode); 16514 addEventListener(el, 'change', () => { 16515 el._assign(getValue(el)); 16516 }); 16517 }, 16518 beforeUpdate(el, { value, oldValue }, vnode) { 16519 el._assign = getModelAssigner(vnode); 16520 if (value !== oldValue) { 16521 el.checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(value, vnode.props.value); 16522 } 16523 } 16524}; 16525const vModelSelect = { 16526 // <select multiple> value need to be deep traversed 16527 deep: true, 16528 created(el, { value, modifiers: { number } }, vnode) { 16529 const isSetModel = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value); 16530 addEventListener(el, 'change', () => { 16531 const selectedVal = Array.prototype.filter 16532 .call(el.options, (o) => o.selected) 16533 .map((o) => number ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(getValue(o)) : getValue(o)); 16534 el._assign(el.multiple 16535 ? isSetModel 16536 ? new Set(selectedVal) 16537 : selectedVal 16538 : selectedVal[0]); 16539 }); 16540 el._assign = getModelAssigner(vnode); 16541 }, 16542 // set value in mounted & updated because <select> relies on its children 16543 // <option>s. 16544 mounted(el, { value }) { 16545 setSelected(el, value); 16546 }, 16547 beforeUpdate(el, _binding, vnode) { 16548 el._assign = getModelAssigner(vnode); 16549 }, 16550 updated(el, { value }) { 16551 setSelected(el, value); 16552 } 16553}; 16554function setSelected(el, value) { 16555 const isMultiple = el.multiple; 16556 if (isMultiple && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value)) { 16557 ( true) && 16558 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`<select multiple v-model> expects an Array or Set value for its binding, ` + 16559 `but got ${Object.prototype.toString.call(value).slice(8, -1)}.`); 16560 return; 16561 } 16562 for (let i = 0, l = el.options.length; i < l; i++) { 16563 const option = el.options[i]; 16564 const optionValue = getValue(option); 16565 if (isMultiple) { 16566 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) { 16567 option.selected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(value, optionValue) > -1; 16568 } 16569 else { 16570 option.selected = value.has(optionValue); 16571 } 16572 } 16573 else { 16574 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(getValue(option), value)) { 16575 if (el.selectedIndex !== i) 16576 el.selectedIndex = i; 16577 return; 16578 } 16579 } 16580 } 16581 if (!isMultiple && el.selectedIndex !== -1) { 16582 el.selectedIndex = -1; 16583 } 16584} 16585// retrieve raw value set via :value bindings 16586function getValue(el) { 16587 return '_value' in el ? el._value : el.value; 16588} 16589// retrieve raw value for true-value and false-value set via :true-value or :false-value bindings 16590function getCheckboxValue(el, checked) { 16591 const key = checked ? '_trueValue' : '_falseValue'; 16592 return key in el ? el[key] : checked; 16593} 16594const vModelDynamic = { 16595 created(el, binding, vnode) { 16596 callModelHook(el, binding, vnode, null, 'created'); 16597 }, 16598 mounted(el, binding, vnode) { 16599 callModelHook(el, binding, vnode, null, 'mounted'); 16600 }, 16601 beforeUpdate(el, binding, vnode, prevVNode) { 16602 callModelHook(el, binding, vnode, prevVNode, 'beforeUpdate'); 16603 }, 16604 updated(el, binding, vnode, prevVNode) { 16605 callModelHook(el, binding, vnode, prevVNode, 'updated'); 16606 } 16607}; 16608function resolveDynamicModel(tagName, type) { 16609 switch (tagName) { 16610 case 'SELECT': 16611 return vModelSelect; 16612 case 'TEXTAREA': 16613 return vModelText; 16614 default: 16615 switch (type) { 16616 case 'checkbox': 16617 return vModelCheckbox; 16618 case 'radio': 16619 return vModelRadio; 16620 default: 16621 return vModelText; 16622 } 16623 } 16624} 16625function callModelHook(el, binding, vnode, prevVNode, hook) { 16626 const modelToUse = resolveDynamicModel(el.tagName, vnode.props && vnode.props.type); 16627 const fn = modelToUse[hook]; 16628 fn && fn(el, binding, vnode, prevVNode); 16629} 16630// SSR vnode transforms, only used when user includes client-oriented render 16631// function in SSR 16632function initVModelForSSR() { 16633 vModelText.getSSRProps = ({ value }) => ({ value }); 16634 vModelRadio.getSSRProps = ({ value }, vnode) => { 16635 if (vnode.props && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(vnode.props.value, value)) { 16636 return { checked: true }; 16637 } 16638 }; 16639 vModelCheckbox.getSSRProps = ({ value }, vnode) => { 16640 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) { 16641 if (vnode.props && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(value, vnode.props.value) > -1) { 16642 return { checked: true }; 16643 } 16644 } 16645 else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value)) { 16646 if (vnode.props && value.has(vnode.props.value)) { 16647 return { checked: true }; 16648 } 16649 } 16650 else if (value) { 16651 return { checked: true }; 16652 } 16653 }; 16654 vModelDynamic.getSSRProps = (binding, vnode) => { 16655 if (typeof vnode.type !== 'string') { 16656 return; 16657 } 16658 const modelToUse = resolveDynamicModel( 16659 // resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase 16660 vnode.type.toUpperCase(), vnode.props && vnode.props.type); 16661 if (modelToUse.getSSRProps) { 16662 return modelToUse.getSSRProps(binding, vnode); 16663 } 16664 }; 16665} 16666 16667const systemModifiers = ['ctrl', 'shift', 'alt', 'meta']; 16668const modifierGuards = { 16669 stop: e => e.stopPropagation(), 16670 prevent: e => e.preventDefault(), 16671 self: e => e.target !== e.currentTarget, 16672 ctrl: e => !e.ctrlKey, 16673 shift: e => !e.shiftKey, 16674 alt: e => !e.altKey, 16675 meta: e => !e.metaKey, 16676 left: e => 'button' in e && e.button !== 0, 16677 middle: e => 'button' in e && e.button !== 1, 16678 right: e => 'button' in e && e.button !== 2, 16679 exact: (e, modifiers) => systemModifiers.some(m => e[`${m}Key`] && !modifiers.includes(m)) 16680}; 16681/** 16682 * @private 16683 */ 16684const withModifiers = (fn, modifiers) => { 16685 return (event, ...args) => { 16686 for (let i = 0; i < modifiers.length; i++) { 16687 const guard = modifierGuards[modifiers[i]]; 16688 if (guard && guard(event, modifiers)) 16689 return; 16690 } 16691 return fn(event, ...args); 16692 }; 16693}; 16694// Kept for 2.x compat. 16695// Note: IE11 compat for `spacebar` and `del` is removed for now. 16696const keyNames = { 16697 esc: 'escape', 16698 space: ' ', 16699 up: 'arrow-up', 16700 left: 'arrow-left', 16701 right: 'arrow-right', 16702 down: 'arrow-down', 16703 delete: 'backspace' 16704}; 16705/** 16706 * @private 16707 */ 16708const withKeys = (fn, modifiers) => { 16709 return (event) => { 16710 if (!('key' in event)) { 16711 return; 16712 } 16713 const eventKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event.key); 16714 if (modifiers.some(k => k === eventKey || keyNames[k] === eventKey)) { 16715 return fn(event); 16716 } 16717 }; 16718}; 16719 16720const vShow = { 16721 beforeMount(el, { value }, { transition }) { 16722 el._vod = el.style.display === 'none' ? '' : el.style.display; 16723 if (transition && value) { 16724 transition.beforeEnter(el); 16725 } 16726 else { 16727 setDisplay(el, value); 16728 } 16729 }, 16730 mounted(el, { value }, { transition }) { 16731 if (transition && value) { 16732 transition.enter(el); 16733 } 16734 }, 16735 updated(el, { value, oldValue }, { transition }) { 16736 if (!value === !oldValue) 16737 return; 16738 if (transition) { 16739 if (value) { 16740 transition.beforeEnter(el); 16741 setDisplay(el, true); 16742 transition.enter(el); 16743 } 16744 else { 16745 transition.leave(el, () => { 16746 setDisplay(el, false); 16747 }); 16748 } 16749 } 16750 else { 16751 setDisplay(el, value); 16752 } 16753 }, 16754 beforeUnmount(el, { value }) { 16755 setDisplay(el, value); 16756 } 16757}; 16758function setDisplay(el, value) { 16759 el.style.display = value ? el._vod : 'none'; 16760} 16761// SSR vnode transforms, only used when user includes client-oriented render 16762// function in SSR 16763function initVShowForSSR() { 16764 vShow.getSSRProps = ({ value }) => { 16765 if (!value) { 16766 return { style: { display: 'none' } }; 16767 } 16768 }; 16769} 16770 16771const rendererOptions = /*#__PURE__*/ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({ patchProp }, nodeOps); 16772// lazy create the renderer - this makes core renderer logic tree-shakable 16773// in case the user only imports reactivity utilities from Vue. 16774let renderer; 16775let enabledHydration = false; 16776function ensureRenderer() { 16777 return (renderer || 16778 (renderer = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createRenderer)(rendererOptions))); 16779} 16780function ensureHydrationRenderer() { 16781 renderer = enabledHydration 16782 ? renderer 16783 : (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer)(rendererOptions); 16784 enabledHydration = true; 16785 return renderer; 16786} 16787// use explicit type casts here to avoid import() calls in rolled-up d.ts 16788const render = ((...args) => { 16789 ensureRenderer().render(...args); 16790}); 16791const hydrate = ((...args) => { 16792 ensureHydrationRenderer().hydrate(...args); 16793}); 16794const createApp = ((...args) => { 16795 const app = ensureRenderer().createApp(...args); 16796 if ((true)) { 16797 injectNativeTagCheck(app); 16798 injectCompilerOptionsCheck(app); 16799 } 16800 const { mount } = app; 16801 app.mount = (containerOrSelector) => { 16802 const container = normalizeContainer(containerOrSelector); 16803 if (!container) 16804 return; 16805 const component = app._component; 16806 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(component) && !component.render && !component.template) { 16807 // __UNSAFE__ 16808 // Reason: potential execution of JS expressions in in-DOM template. 16809 // The user must make sure the in-DOM template is trusted. If it's 16810 // rendered by the server, the template should not contain any user data. 16811 component.template = container.innerHTML; 16812 } 16813 // clear content before mounting 16814 container.innerHTML = ''; 16815 const proxy = mount(container, false, container instanceof SVGElement); 16816 if (container instanceof Element) { 16817 container.removeAttribute('v-cloak'); 16818 container.setAttribute('data-v-app', ''); 16819 } 16820 return proxy; 16821 }; 16822 return app; 16823}); 16824const createSSRApp = ((...args) => { 16825 const app = ensureHydrationRenderer().createApp(...args); 16826 if ((true)) { 16827 injectNativeTagCheck(app); 16828 injectCompilerOptionsCheck(app); 16829 } 16830 const { mount } = app; 16831 app.mount = (containerOrSelector) => { 16832 const container = normalizeContainer(containerOrSelector); 16833 if (container) { 16834 return mount(container, true, container instanceof SVGElement); 16835 } 16836 }; 16837 return app; 16838}); 16839function injectNativeTagCheck(app) { 16840 // Inject `isNativeTag` 16841 // this is used for component name validation (dev only) 16842 Object.defineProperty(app.config, 'isNativeTag', { 16843 value: (tag) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isHTMLTag)(tag) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSVGTag)(tag), 16844 writable: false 16845 }); 16846} 16847// dev only 16848function injectCompilerOptionsCheck(app) { 16849 if ((0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly)()) { 16850 const isCustomElement = app.config.isCustomElement; 16851 Object.defineProperty(app.config, 'isCustomElement', { 16852 get() { 16853 return isCustomElement; 16854 }, 16855 set() { 16856 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`The \`isCustomElement\` config option is deprecated. Use ` + 16857 `\`compilerOptions.isCustomElement\` instead.`); 16858 } 16859 }); 16860 const compilerOptions = app.config.compilerOptions; 16861 const msg = `The \`compilerOptions\` config option is only respected when using ` + 16862 `a build of Vue.js that includes the runtime compiler (aka "full build"). ` + 16863 `Since you are using the runtime-only build, \`compilerOptions\` ` + 16864 `must be passed to \`@vue/compiler-dom\` in the build setup instead.\n` + 16865 `- For vue-loader: pass it via vue-loader's \`compilerOptions\` loader option.\n` + 16866 `- For vue-cli: see https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader\n` + 16867 `- For vite: pass it via @vitejs/plugin-vue options. See https://github.com/vitejs/vite/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-dom`; 16868 Object.defineProperty(app.config, 'compilerOptions', { 16869 get() { 16870 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(msg); 16871 return compilerOptions; 16872 }, 16873 set() { 16874 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(msg); 16875 } 16876 }); 16877 } 16878} 16879function normalizeContainer(container) { 16880 if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(container)) { 16881 const res = document.querySelector(container); 16882 if (( true) && !res) { 16883 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Failed to mount app: mount target selector "${container}" returned null.`); 16884 } 16885 return res; 16886 } 16887 if (( true) && 16888 window.ShadowRoot && 16889 container instanceof window.ShadowRoot && 16890 container.mode === 'closed') { 16891 (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`mounting on a ShadowRoot with \`{mode: "closed"}\` may lead to unpredictable bugs`); 16892 } 16893 return container; 16894} 16895let ssrDirectiveInitialized = false; 16896/** 16897 * @internal 16898 */ 16899const initDirectivesForSSR = () => { 16900 if (!ssrDirectiveInitialized) { 16901 ssrDirectiveInitialized = true; 16902 initVModelForSSR(); 16903 initVShowForSSR(); 16904 } 16905 } 16906 ; 16907 16908 16909 16910 16911/***/ }), 16912
vendor: 28,332 bytes, lines 16913-17573
16913/***/ "./node_modules/@vue/shared/dist/shared.esm-bundler.js": 16914/*!*************************************************************!*\ 16915 !*** ./node_modules/@vue/shared/dist/shared.esm-bundler.js ***! 16916 \*************************************************************/ 16917/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 16918 16919"use strict"; 16920__webpack_require__.r(__webpack_exports__); 16921/* harmony export */ __webpack_require__.d(__webpack_exports__, { 16922/* harmony export */ "EMPTY_ARR": function() { return /* binding */ EMPTY_ARR; }, 16923/* harmony export */ "EMPTY_OBJ": function() { return /* binding */ EMPTY_OBJ; }, 16924/* harmony export */ "NO": function() { return /* binding */ NO; }, 16925/* harmony export */ "NOOP": function() { return /* binding */ NOOP; }, 16926/* harmony export */ "PatchFlagNames": function() { return /* binding */ PatchFlagNames; }, 16927/* harmony export */ "camelize": function() { return /* binding */ camelize; }, 16928/* harmony export */ "capitalize": function() { return /* binding */ capitalize; }, 16929/* harmony export */ "def": function() { return /* binding */ def; }, 16930/* harmony export */ "escapeHtml": function() { return /* binding */ escapeHtml; }, 16931/* harmony export */ "escapeHtmlComment": function() { return /* binding */ escapeHtmlComment; }, 16932/* harmony export */ "extend": function() { return /* binding */ extend; }, 16933/* harmony export */ "genPropsAccessExp": function() { return /* binding */ genPropsAccessExp; }, 16934/* harmony export */ "generateCodeFrame": function() { return /* binding */ generateCodeFrame; }, 16935/* harmony export */ "getGlobalThis": function() { return /* binding */ getGlobalThis; }, 16936/* harmony export */ "hasChanged": function() { return /* binding */ hasChanged; }, 16937/* harmony export */ "hasOwn": function() { return /* binding */ hasOwn; }, 16938/* harmony export */ "hyphenate": function() { return /* binding */ hyphenate; }, 16939/* harmony export */ "includeBooleanAttr": function() { return /* binding */ includeBooleanAttr; }, 16940/* harmony export */ "invokeArrayFns": function() { return /* binding */ invokeArrayFns; }, 16941/* harmony export */ "isArray": function() { return /* binding */ isArray; }, 16942/* harmony export */ "isBooleanAttr": function() { return /* binding */ isBooleanAttr; }, 16943/* harmony export */ "isBuiltInDirective": function() { return /* binding */ isBuiltInDirective; }, 16944/* harmony export */ "isDate": function() { return /* binding */ isDate; }, 16945/* harmony export */ "isFunction": function() { return /* binding */ isFunction; }, 16946/* harmony export */ "isGloballyWhitelisted": function() { return /* binding */ isGloballyWhitelisted; }, 16947/* harmony export */ "isHTMLTag": function() { return /* binding */ isHTMLTag; }, 16948/* harmony export */ "isIntegerKey": function() { return /* binding */ isIntegerKey; }, 16949/* harmony export */ "isKnownHtmlAttr": function() { return /* binding */ isKnownHtmlAttr; }, 16950/* harmony export */ "isKnownSvgAttr": function() { return /* binding */ isKnownSvgAttr; }, 16951/* harmony export */ "isMap": function() { return /* binding */ isMap; }, 16952/* harmony export */ "isModelListener": function() { return /* binding */ isModelListener; }, 16953/* harmony export */ "isObject": function() { return /* binding */ isObject; }, 16954/* harmony export */ "isOn": function() { return /* binding */ isOn; }, 16955/* harmony export */ "isPlainObject": function() { return /* binding */ isPlainObject; }, 16956/* harmony export */ "isPromise": function() { return /* binding */ isPromise; }, 16957/* harmony export */ "isReservedProp": function() { return /* binding */ isReservedProp; }, 16958/* harmony export */ "isSSRSafeAttrName": function() { return /* binding */ isSSRSafeAttrName; }, 16959/* harmony export */ "isSVGTag": function() { return /* binding */ isSVGTag; }, 16960/* harmony export */ "isSet": function() { return /* binding */ isSet; }, 16961/* harmony export */ "isSpecialBooleanAttr": function() { return /* binding */ isSpecialBooleanAttr; }, 16962/* harmony export */ "isString": function() { return /* binding */ isString; }, 16963/* harmony export */ "isSymbol": function() { return /* binding */ isSymbol; }, 16964/* harmony export */ "isVoidTag": function() { return /* binding */ isVoidTag; }, 16965/* harmony export */ "looseEqual": function() { return /* binding */ looseEqual; }, 16966/* harmony export */ "looseIndexOf": function() { return /* binding */ looseIndexOf; }, 16967/* harmony export */ "makeMap": function() { return /* binding */ makeMap; }, 16968/* harmony export */ "normalizeClass": function() { return /* binding */ normalizeClass; }, 16969/* harmony export */ "normalizeProps": function() { return /* binding */ normalizeProps; }, 16970/* harmony export */ "normalizeStyle": function() { return /* binding */ normalizeStyle; }, 16971/* harmony export */ "objectToString": function() { return /* binding */ objectToString; }, 16972/* harmony export */ "parseStringStyle": function() { return /* binding */ parseStringStyle; }, 16973/* harmony export */ "propsToAttrMap": function() { return /* binding */ propsToAttrMap; }, 16974/* harmony export */ "remove": function() { return /* binding */ remove; }, 16975/* harmony export */ "slotFlagsText": function() { return /* binding */ slotFlagsText; }, 16976/* harmony export */ "stringifyStyle": function() { return /* binding */ stringifyStyle; }, 16977/* harmony export */ "toDisplayString": function() { return /* binding */ toDisplayString; }, 16978/* harmony export */ "toHandlerKey": function() { return /* binding */ toHandlerKey; }, 16979/* harmony export */ "toNumber": function() { return /* binding */ toNumber; }, 16980/* harmony export */ "toRawType": function() { return /* binding */ toRawType; }, 16981/* harmony export */ "toTypeString": function() { return /* binding */ toTypeString; } 16982/* harmony export */ }); 16983/** 16984 * Make a map and return a function for checking if a key 16985 * is in that map. 16986 * IMPORTANT: all calls of this function must be prefixed with 16987 * \/\*#\_\_PURE\_\_\*\/ 16988 * So that rollup can tree-shake them if necessary. 16989 */ 16990function makeMap(str, expectsLowerCase) { 16991 const map = Object.create(null); 16992 const list = str.split(','); 16993 for (let i = 0; i < list.length; i++) { 16994 map[list[i]] = true; 16995 } 16996 return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val]; 16997} 16998 16999/** 17000 * dev only flag -> name mapping 17001 */ 17002const PatchFlagNames = { 17003 [1 /* PatchFlags.TEXT */]: `TEXT`, 17004 [2 /* PatchFlags.CLASS */]: `CLASS`, 17005 [4 /* PatchFlags.STYLE */]: `STYLE`, 17006 [8 /* PatchFlags.PROPS */]: `PROPS`, 17007 [16 /* PatchFlags.FULL_PROPS */]: `FULL_PROPS`, 17008 [32 /* PatchFlags.HYDRATE_EVENTS */]: `HYDRATE_EVENTS`, 17009 [64 /* PatchFlags.STABLE_FRAGMENT */]: `STABLE_FRAGMENT`, 17010 [128 /* PatchFlags.KEYED_FRAGMENT */]: `KEYED_FRAGMENT`, 17011 [256 /* PatchFlags.UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`, 17012 [512 /* PatchFlags.NEED_PATCH */]: `NEED_PATCH`, 17013 [1024 /* PatchFlags.DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`, 17014 [2048 /* PatchFlags.DEV_ROOT_FRAGMENT */]: `DEV_ROOT_FRAGMENT`, 17015 [-1 /* PatchFlags.HOISTED */]: `HOISTED`, 17016 [-2 /* PatchFlags.BAIL */]: `BAIL` 17017}; 17018 17019/** 17020 * Dev only 17021 */ 17022const slotFlagsText = { 17023 [1 /* SlotFlags.STABLE */]: 'STABLE', 17024 [2 /* SlotFlags.DYNAMIC */]: 'DYNAMIC', 17025 [3 /* SlotFlags.FORWARDED */]: 'FORWARDED' 17026}; 17027 17028const GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + 17029 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + 17030 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt'; 17031const isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED); 17032 17033const range = 2; 17034function generateCodeFrame(source, start = 0, end = source.length) { 17035 // Split the content into individual lines but capture the newline sequence 17036 // that separated each line. This is important because the actual sequence is 17037 // needed to properly take into account the full line length for offset 17038 // comparison 17039 let lines = source.split(/(\r?\n)/); 17040 // Separate the lines and newline sequences into separate arrays for easier referencing 17041 const newlineSequences = lines.filter((_, idx) => idx % 2 === 1); 17042 lines = lines.filter((_, idx) => idx % 2 === 0); 17043 let count = 0; 17044 const res = []; 17045 for (let i = 0; i < lines.length; i++) { 17046 count += 17047 lines[i].length + 17048 ((newlineSequences[i] && newlineSequences[i].length) || 0); 17049 if (count >= start) { 17050 for (let j = i - range; j <= i + range || end > count; j++) { 17051 if (j < 0 || j >= lines.length) 17052 continue; 17053 const line = j + 1; 17054 res.push(`${line}${' '.repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`); 17055 const lineLength = lines[j].length; 17056 const newLineSeqLength = (newlineSequences[j] && newlineSequences[j].length) || 0; 17057 if (j === i) { 17058 // push underline 17059 const pad = start - (count - (lineLength + newLineSeqLength)); 17060 const length = Math.max(1, end > count ? lineLength - pad : end - start); 17061 res.push(` | ` + ' '.repeat(pad) + '^'.repeat(length)); 17062 } 17063 else if (j > i) { 17064 if (end > count) { 17065 const length = Math.max(Math.min(end - count, lineLength), 1); 17066 res.push(` | ` + '^'.repeat(length)); 17067 } 17068 count += lineLength + newLineSeqLength; 17069 } 17070 } 17071 break; 17072 } 17073 } 17074 return res.join('\n'); 17075} 17076 17077function normalizeStyle(value) { 17078 if (isArray(value)) { 17079 const res = {}; 17080 for (let i = 0; i < value.length; i++) { 17081 const item = value[i]; 17082 const normalized = isString(item) 17083 ? parseStringStyle(item) 17084 : normalizeStyle(item); 17085 if (normalized) { 17086 for (const key in normalized) { 17087 res[key] = normalized[key]; 17088 } 17089 } 17090 } 17091 return res; 17092 } 17093 else if (isString(value)) { 17094 return value; 17095 } 17096 else if (isObject(value)) { 17097 return value; 17098 } 17099} 17100const listDelimiterRE = /;(?![^(]*\))/g; 17101const propertyDelimiterRE = /:([^]+)/; 17102const styleCommentRE = /\/\*.*?\*\//gs; 17103function parseStringStyle(cssText) { 17104 const ret = {}; 17105 cssText 17106 .replace(styleCommentRE, '') 17107 .split(listDelimiterRE) 17108 .forEach(item => { 17109 if (item) { 17110 const tmp = item.split(propertyDelimiterRE); 17111 tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); 17112 } 17113 }); 17114 return ret; 17115} 17116function stringifyStyle(styles) { 17117 let ret = ''; 17118 if (!styles || isString(styles)) { 17119 return ret; 17120 } 17121 for (const key in styles) { 17122 const value = styles[key]; 17123 const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key); 17124 if (isString(value) || typeof value === 'number') { 17125 // only render valid values 17126 ret += `${normalizedKey}:${value};`; 17127 } 17128 } 17129 return ret; 17130} 17131function normalizeClass(value) { 17132 let res = ''; 17133 if (isString(value)) { 17134 res = value; 17135 } 17136 else if (isArray(value)) { 17137 for (let i = 0; i < value.length; i++) { 17138 const normalized = normalizeClass(value[i]); 17139 if (normalized) { 17140 res += normalized + ' '; 17141 } 17142 } 17143 } 17144 else if (isObject(value)) { 17145 for (const name in value) { 17146 if (value[name]) { 17147 res += name + ' '; 17148 } 17149 } 17150 } 17151 return res.trim(); 17152} 17153function normalizeProps(props) { 17154 if (!props) 17155 return null; 17156 let { class: klass, style } = props; 17157 if (klass && !isString(klass)) { 17158 props.class = normalizeClass(klass); 17159 } 17160 if (style) { 17161 props.style = normalizeStyle(style); 17162 } 17163 return props; 17164} 17165 17166// These tag configs are shared between compiler-dom and runtime-dom, so they 17167// https://developer.mozilla.org/en-US/docs/Web/HTML/Element 17168const HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' + 17169 'header,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,' + 17170 'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' + 17171 'data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,' + 17172 'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' + 17173 'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' + 17174 'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' + 17175 'option,output,progress,select,textarea,details,dialog,menu,' + 17176 'summary,template,blockquote,iframe,tfoot'; 17177// https://developer.mozilla.org/en-US/docs/Web/SVG/Element 17178const SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' + 17179 'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' + 17180 'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' + 17181 'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' + 17182 'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' + 17183 'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' + 17184 'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' + 17185 'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' + 17186 'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' + 17187 'text,textPath,title,tspan,unknown,use,view'; 17188const VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr'; 17189/** 17190 * Compiler only. 17191 * Do NOT use in runtime code paths unless behind `(process.env.NODE_ENV !== 'production')` flag. 17192 */ 17193const isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS); 17194/** 17195 * Compiler only. 17196 * Do NOT use in runtime code paths unless behind `(process.env.NODE_ENV !== 'production')` flag. 17197 */ 17198const isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS); 17199/** 17200 * Compiler only. 17201 * Do NOT use in runtime code paths unless behind `(process.env.NODE_ENV !== 'production')` flag. 17202 */ 17203const isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS); 17204 17205/** 17206 * On the client we only need to offer special cases for boolean attributes that 17207 * have different names from their corresponding dom properties: 17208 * - itemscope -> N/A 17209 * - allowfullscreen -> allowFullscreen 17210 * - formnovalidate -> formNoValidate 17211 * - ismap -> isMap 17212 * - nomodule -> noModule 17213 * - novalidate -> noValidate 17214 * - readonly -> readOnly 17215 */ 17216const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`; 17217const isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs); 17218/** 17219 * The full list is needed during SSR to produce the correct initial markup. 17220 */ 17221const isBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs + 17222 `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,` + 17223 `loop,open,required,reversed,scoped,seamless,` + 17224 `checked,muted,multiple,selected`); 17225/** 17226 * Boolean attributes should be included if the value is truthy or ''. 17227 * e.g. `<select multiple>` compiles to `{ multiple: '' }` 17228 */ 17229function includeBooleanAttr(value) { 17230 return !!value || value === ''; 17231} 17232const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; 17233const attrValidationCache = {}; 17234function isSSRSafeAttrName(name) { 17235 if (attrValidationCache.hasOwnProperty(name)) { 17236 return attrValidationCache[name]; 17237 } 17238 const isUnsafe = unsafeAttrCharRE.test(name); 17239 if (isUnsafe) { 17240 console.error(`unsafe attribute name: ${name}`); 17241 } 17242 return (attrValidationCache[name] = !isUnsafe); 17243} 17244const propsToAttrMap = { 17245 acceptCharset: 'accept-charset', 17246 className: 'class', 17247 htmlFor: 'for', 17248 httpEquiv: 'http-equiv' 17249}; 17250/** 17251 * Known attributes, this is used for stringification of runtime static nodes 17252 * so that we don't stringify bindings that cannot be set from HTML. 17253 * Don't also forget to allow `data-*` and `aria-*`! 17254 * Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes 17255 */ 17256const isKnownHtmlAttr = /*#__PURE__*/ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,` + 17257 `autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,` + 17258 `border,buffered,capture,challenge,charset,checked,cite,class,code,` + 17259 `codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,` + 17260 `coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,` + 17261 `disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,` + 17262 `formaction,formenctype,formmethod,formnovalidate,formtarget,headers,` + 17263 `height,hidden,high,href,hreflang,http-equiv,icon,id,importance,integrity,` + 17264 `ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,` + 17265 `manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,` + 17266 `open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,` + 17267 `referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,` + 17268 `selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,` + 17269 `start,step,style,summary,tabindex,target,title,translate,type,usemap,` + 17270 `value,width,wrap`); 17271/** 17272 * Generated from https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute 17273 */ 17274const isKnownSvgAttr = /*#__PURE__*/ makeMap(`xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,` + 17275 `arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,` + 17276 `baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,` + 17277 `clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,` + 17278 `color-interpolation-filters,color-profile,color-rendering,` + 17279 `contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,` + 17280 `descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,` + 17281 `dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,` + 17282 `fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,` + 17283 `font-family,font-size,font-size-adjust,font-stretch,font-style,` + 17284 `font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,` + 17285 `glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,` + 17286 `gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,` + 17287 `horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,` + 17288 `k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,` + 17289 `lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,` + 17290 `marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,` + 17291 `mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,` + 17292 `name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,` + 17293 `overflow,overline-position,overline-thickness,panose-1,paint-order,path,` + 17294 `pathLength,patternContentUnits,patternTransform,patternUnits,ping,` + 17295 `pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,` + 17296 `preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,` + 17297 `rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,` + 17298 `restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,` + 17299 `specularConstant,specularExponent,speed,spreadMethod,startOffset,` + 17300 `stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,` + 17301 `strikethrough-position,strikethrough-thickness,string,stroke,` + 17302 `stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,` + 17303 `stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,` + 17304 `systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,` + 17305 `text-decoration,text-rendering,textLength,to,transform,transform-origin,` + 17306 `type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,` + 17307 `unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,` + 17308 `v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,` + 17309 `vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,` + 17310 `writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,` + 17311 `xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xml:base,xml:lang,` + 17312 `xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`); 17313 17314const escapeRE = /["'&<>]/; 17315function escapeHtml(string) { 17316 const str = '' + string; 17317 const match = escapeRE.exec(str); 17318 if (!match) { 17319 return str; 17320 } 17321 let html = ''; 17322 let escaped; 17323 let index; 17324 let lastIndex = 0; 17325 for (index = match.index; index < str.length; index++) { 17326 switch (str.charCodeAt(index)) { 17327 case 34: // " 17328 escaped = '"'; 17329 break; 17330 case 38: // & 17331 escaped = '&'; 17332 break; 17333 case 39: // ' 17334 escaped = '''; 17335 break; 17336 case 60: // < 17337 escaped = '<'; 17338 break; 17339 case 62: // > 17340 escaped = '>'; 17341 break; 17342 default: 17343 continue; 17344 } 17345 if (lastIndex !== index) { 17346 html += str.slice(lastIndex, index); 17347 } 17348 lastIndex = index + 1; 17349 html += escaped; 17350 } 17351 return lastIndex !== index ? html + str.slice(lastIndex, index) : html; 17352} 17353// https://www.w3.org/TR/html52/syntax.html#comments 17354const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g; 17355function escapeHtmlComment(src) { 17356 return src.replace(commentStripRE, ''); 17357} 17358 17359function looseCompareArrays(a, b) { 17360 if (a.length !== b.length) 17361 return false; 17362 let equal = true; 17363 for (let i = 0; equal && i < a.length; i++) { 17364 equal = looseEqual(a[i], b[i]); 17365 } 17366 return equal; 17367} 17368function looseEqual(a, b) { 17369 if (a === b) 17370 return true; 17371 let aValidType = isDate(a); 17372 let bValidType = isDate(b); 17373 if (aValidType || bValidType) { 17374 return aValidType && bValidType ? a.getTime() === b.getTime() : false; 17375 } 17376 aValidType = isSymbol(a); 17377 bValidType = isSymbol(b); 17378 if (aValidType || bValidType) { 17379 return a === b; 17380 } 17381 aValidType = isArray(a); 17382 bValidType = isArray(b); 17383 if (aValidType || bValidType) { 17384 return aValidType && bValidType ? looseCompareArrays(a, b) : false; 17385 } 17386 aValidType = isObject(a); 17387 bValidType = isObject(b); 17388 if (aValidType || bValidType) { 17389 /* istanbul ignore if: this if will probably never be called */ 17390 if (!aValidType || !bValidType) { 17391 return false; 17392 } 17393 const aKeysCount = Object.keys(a).length; 17394 const bKeysCount = Object.keys(b).length; 17395 if (aKeysCount !== bKeysCount) { 17396 return false; 17397 } 17398 for (const key in a) { 17399 const aHasKey = a.hasOwnProperty(key); 17400 const bHasKey = b.hasOwnProperty(key); 17401 if ((aHasKey && !bHasKey) || 17402 (!aHasKey && bHasKey) || 17403 !looseEqual(a[key], b[key])) { 17404 return false; 17405 } 17406 } 17407 } 17408 return String(a) === String(b); 17409} 17410function looseIndexOf(arr, val) { 17411 return arr.findIndex(item => looseEqual(item, val)); 17412} 17413 17414/** 17415 * For converting {{ interpolation }} values to displayed strings. 17416 * @private 17417 */ 17418const toDisplayString = (val) => { 17419 return isString(val) 17420 ? val 17421 : val == null 17422 ? '' 17423 : isArray(val) || 17424 (isObject(val) && 17425 (val.toString === objectToString || !isFunction(val.toString))) 17426 ? JSON.stringify(val, replacer, 2) 17427 : String(val); 17428}; 17429const replacer = (_key, val) => { 17430 // can't use isRef here since @vue/shared has no deps 17431 if (val && val.__v_isRef) { 17432 return replacer(_key, val.value); 17433 } 17434 else if (isMap(val)) { 17435 return { 17436 [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => { 17437 entries[`${key} =>`] = val; 17438 return entries; 17439 }, {}) 17440 }; 17441 } 17442 else if (isSet(val)) { 17443 return { 17444 [`Set(${val.size})`]: [...val.values()] 17445 }; 17446 } 17447 else if (isObject(val) && !isArray(val) && !isPlainObject(val)) { 17448 return String(val); 17449 } 17450 return val; 17451}; 17452 17453const EMPTY_OBJ = ( true) 17454 ? Object.freeze({}) 17455 : 0; 17456const EMPTY_ARR = ( true) ? Object.freeze([]) : 0; 17457const NOOP = () => { }; 17458/** 17459 * Always return false. 17460 */ 17461const NO = () => false; 17462const onRE = /^on[^a-z]/; 17463const isOn = (key) => onRE.test(key); 17464const isModelListener = (key) => key.startsWith('onUpdate:'); 17465const extend = Object.assign; 17466const remove = (arr, el) => { 17467 const i = arr.indexOf(el); 17468 if (i > -1) { 17469 arr.splice(i, 1); 17470 } 17471}; 17472const hasOwnProperty = Object.prototype.hasOwnProperty; 17473const hasOwn = (val, key) => hasOwnProperty.call(val, key); 17474const isArray = Array.isArray; 17475const isMap = (val) => toTypeString(val) === '[object Map]'; 17476const isSet = (val) => toTypeString(val) === '[object Set]'; 17477const isDate = (val) => toTypeString(val) === '[object Date]'; 17478const isFunction = (val) => typeof val === 'function'; 17479const isString = (val) => typeof val === 'string'; 17480const isSymbol = (val) => typeof val === 'symbol'; 17481const isObject = (val) => val !== null && typeof val === 'object'; 17482const isPromise = (val) => { 17483 return isObject(val) && isFunction(val.then) && isFunction(val.catch); 17484}; 17485const objectToString = Object.prototype.toString; 17486const toTypeString = (value) => objectToString.call(value); 17487const toRawType = (value) => { 17488 // extract "RawType" from strings like "[object RawType]" 17489 return toTypeString(value).slice(8, -1); 17490}; 17491const isPlainObject = (val) => toTypeString(val) === '[object Object]'; 17492const isIntegerKey = (key) => isString(key) && 17493 key !== 'NaN' && 17494 key[0] !== '-' && 17495 '' + parseInt(key, 10) === key; 17496const isReservedProp = /*#__PURE__*/ makeMap( 17497// the leading comma is intentional so empty string "" is also included 17498',key,ref,ref_for,ref_key,' + 17499 'onVnodeBeforeMount,onVnodeMounted,' + 17500 'onVnodeBeforeUpdate,onVnodeUpdated,' + 17501 'onVnodeBeforeUnmount,onVnodeUnmounted'); 17502const isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo'); 17503const cacheStringFunction = (fn) => { 17504 const cache = Object.create(null); 17505 return ((str) => { 17506 const hit = cache[str]; 17507 return hit || (cache[str] = fn(str)); 17508 }); 17509}; 17510const camelizeRE = /-(\w)/g; 17511/** 17512 * @private 17513 */ 17514const camelize = cacheStringFunction((str) => { 17515 return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : '')); 17516}); 17517const hyphenateRE = /\B([A-Z])/g; 17518/** 17519 * @private 17520 */ 17521const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase()); 17522/** 17523 * @private 17524 */ 17525const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1)); 17526/** 17527 * @private 17528 */ 17529const toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``); 17530// compare whether a value has changed, accounting for NaN. 17531const hasChanged = (value, oldValue) => !Object.is(value, oldValue); 17532const invokeArrayFns = (fns, arg) => { 17533 for (let i = 0; i < fns.length; i++) { 17534 fns[i](arg); 17535 } 17536}; 17537const def = (obj, key, value) => { 17538 Object.defineProperty(obj, key, { 17539 configurable: true, 17540 enumerable: false, 17541 value 17542 }); 17543}; 17544const toNumber = (val) => { 17545 const n = parseFloat(val); 17546 return isNaN(n) ? val : n; 17547}; 17548let _globalThis; 17549const getGlobalThis = () => { 17550 return (_globalThis || 17551 (_globalThis = 17552 typeof globalThis !== 'undefined' 17553 ? globalThis 17554 : typeof self !== 'undefined' 17555 ? self 17556 : typeof window !== 'undefined' 17557 ? window 17558 : typeof __webpack_require__.g !== 'undefined' 17559 ? __webpack_require__.g 17560 : {})); 17561}; 17562const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/; 17563function genPropsAccessExp(name) { 17564 return identRE.test(name) 17565 ? `__props.${name}` 17566 : `__props[${JSON.stringify(name)}]`; 17567} 17568 17569 17570 17571 17572/***/ }), 17573
vendor: 41,930 bytes, lines 17574-18734
17574/***/ "./node_modules/@vuelidate/core/dist/index.esm.js": 17575/*!********************************************************!*\ 17576 !*** ./node_modules/@vuelidate/core/dist/index.esm.js ***! 17577 \********************************************************/ 17578/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 17579 17580"use strict"; 17581__webpack_require__.r(__webpack_exports__); 17582/* harmony export */ __webpack_require__.d(__webpack_exports__, { 17583/* harmony export */ "CollectFlag": function() { return /* binding */ CollectFlag; }, 17584/* harmony export */ "default": function() { return /* binding */ useVuelidate; }, 17585/* harmony export */ "useVuelidate": function() { return /* binding */ useVuelidate; } 17586/* harmony export */ }); 17587/* harmony import */ var vue_demi__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue-demi */ "./node_modules/vue-demi/lib/index.mjs"); 17588 17589 17590function unwrapObj(obj) { 17591 let ignoreKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 17592 return Object.keys(obj).reduce((o, k) => { 17593 if (ignoreKeys.includes(k)) return o; 17594 o[k] = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(obj[k]); 17595 return o; 17596 }, {}); 17597} 17598function isFunction(val) { 17599 return typeof val === 'function'; 17600} 17601function isProxy(value) { 17602 return (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isReactive)(value) || (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isReadonly)(value); 17603} 17604function get(obj, stringPath, def) { 17605 // Cache the current object 17606 let current = obj; 17607 const path = stringPath.split('.'); // For each item in the path, dig into the object 17608 17609 for (let i = 0; i < path.length; i++) { 17610 // If the item isn't found, return the default (or null) 17611 if (!current[path[i]]) return def; // Otherwise, update the current value 17612 17613 current = current[path[i]]; 17614 } 17615 17616 return current; 17617} 17618function gatherBooleanGroupProperties(group, nestedResults, property) { 17619 return (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 17620 return group.some(path => { 17621 return get(nestedResults, path, { 17622 [property]: false 17623 })[property]; 17624 }); 17625 }); 17626} 17627function gatherArrayGroupProperties(group, nestedResults, property) { 17628 return (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 17629 return group.reduce((all, path) => { 17630 const fetchedProperty = get(nestedResults, path, { 17631 [property]: false 17632 })[property] || []; 17633 return all.concat(fetchedProperty); 17634 }, []); 17635 }); 17636} 17637 17638/** 17639 * Response form a raw Validator function. 17640 * Should return a Boolean or an object with $invalid property. 17641 * @typedef {Boolean | { $valid: Boolean }} ValidatorResponse 17642 */ 17643 17644/** 17645 * Calls a validation rule by unwrapping its value first from a ref. 17646 * @param {Validator} rule 17647 * @param {Ref} value 17648 * @param {VueInstance} instance 17649 * @param {Object} siblingState 17650 * @return {Promise<ValidatorResponse> | ValidatorResponse} 17651 */ 17652 17653function callRule(rule, value, siblingState, instance) { 17654 return rule.call(instance, (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(value), (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(siblingState), instance); 17655} 17656/** 17657 * Normalizes the validator result 17658 * Allows passing a boolean of an object like `{ $valid: Boolean }` 17659 * @param {ValidatorResponse} result - Validator result 17660 * @return {boolean} 17661 */ 17662 17663 17664function normalizeValidatorResponse(result) { 17665 return result.$valid !== undefined ? !result.$valid : !result; 17666} 17667/** 17668 * Returns the result of an async validator. 17669 * @param {Validator} rule 17670 * @param {Ref<*>} model 17671 * @param {Ref<Boolean>} $pending 17672 * @param {Ref<Boolean>} $dirty 17673 * @param {GlobalConfig} config 17674 * @param {boolean} config.$lazy 17675 * @param {Ref<*>} $response 17676 * @param {VueInstance} instance 17677 * @param {Ref<*>[]} watchTargets 17678 * @param {Object} siblingState 17679 * @param {Ref<Boolean>} $lastInvalidState 17680 * @param {Ref<Number>} $lastCommittedOn 17681 * @return {{ $invalid: Ref<Boolean>, $unwatch: WatchStopHandle }} 17682 */ 17683 17684 17685function createAsyncResult(rule, model, $pending, $dirty, _ref, $response, instance) { 17686 let { 17687 $lazy, 17688 $rewardEarly 17689 } = _ref; 17690 let watchTargets = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : []; 17691 let siblingState = arguments.length > 8 ? arguments[8] : undefined; 17692 let $lastInvalidState = arguments.length > 9 ? arguments[9] : undefined; 17693 let $lastCommittedOn = arguments.length > 10 ? arguments[10] : undefined; 17694 const $invalid = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)(!!$dirty.value); 17695 const $pendingCounter = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)(0); 17696 $pending.value = false; 17697 const $unwatch = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.watch)([model, $dirty].concat(watchTargets, $lastCommittedOn), () => { 17698 if ( // if $lazy and not dirty, return 17699 $lazy && !$dirty.value || // if in $rewardEarly mode and no previous errors, nothing pending, return 17700 $rewardEarly && !$lastInvalidState.value && !$pending.value) { 17701 return; 17702 } 17703 17704 let ruleResult; // make sure we dont break if a validator throws 17705 17706 try { 17707 ruleResult = callRule(rule, model, siblingState, instance); 17708 } catch (err) { 17709 // convert to a promise, so we can handle it async 17710 ruleResult = Promise.reject(err); 17711 } 17712 17713 $pendingCounter.value++; 17714 $pending.value = !!$pendingCounter.value; // ensure $invalid is false, while validator is resolving 17715 17716 $invalid.value = false; 17717 Promise.resolve(ruleResult).then(data => { 17718 $pendingCounter.value--; 17719 $pending.value = !!$pendingCounter.value; 17720 $response.value = data; 17721 $invalid.value = normalizeValidatorResponse(data); 17722 }).catch(error => { 17723 $pendingCounter.value--; 17724 $pending.value = !!$pendingCounter.value; 17725 $response.value = error; 17726 $invalid.value = true; 17727 }); 17728 }, { 17729 immediate: true, 17730 deep: typeof model === 'object' 17731 }); 17732 return { 17733 $invalid, 17734 $unwatch 17735 }; 17736} 17737/** 17738 * Returns the result of a sync validator 17739 * @param {Validator} rule 17740 * @param {Ref<*>} model 17741 * @param {Ref<Boolean>} $dirty 17742 * @param {GlobalConfig} config 17743 * @param {Boolean} config.$lazy 17744 * @param {Ref<*>} $response 17745 * @param {VueInstance} instance 17746 * @param {Object} siblingState 17747 * @param {Ref<Boolean>} $lastInvalidState 17748 * @return {{$unwatch: (function(): {}), $invalid: ComputedRef<boolean>}} 17749 */ 17750 17751 17752function createSyncResult(rule, model, $dirty, _ref2, $response, instance, siblingState, $lastInvalidState) { 17753 let { 17754 $lazy, 17755 $rewardEarly 17756 } = _ref2; 17757 17758 const $unwatch = () => ({}); 17759 17760 const $invalid = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 17761 if ( // return early if $lazy mode and not touched 17762 $lazy && !$dirty.value || // If $rewardEarly mode is ON and last invalid was false (no error), return it. 17763 // If we want to invalidate, we just flip the last state to true, causing the computed to run again 17764 $rewardEarly && !$lastInvalidState.value) { 17765 return false; 17766 } 17767 17768 let returnValue = true; 17769 17770 try { 17771 const result = callRule(rule, model, siblingState, instance); 17772 $response.value = result; 17773 returnValue = normalizeValidatorResponse(result); 17774 } catch (err) { 17775 $response.value = err; 17776 } 17777 17778 return returnValue; 17779 }); 17780 return { 17781 $unwatch, 17782 $invalid 17783 }; 17784} 17785/** 17786 * Returns the validation result. 17787 * Detects async and sync validators. 17788 * @param {NormalizedValidator} rule 17789 * @param {Ref<*>} model 17790 * @param {Ref<boolean>} $dirty 17791 * @param {GlobalConfig} config - Vuelidate config 17792 * @param {VueInstance} instance - component instance 17793 * @param {string} validatorName - name of the current validator 17794 * @param {string} propertyKey - the current property we are validating 17795 * @param {string} propertyPath - the deep path to the validated property 17796 * @param {Object} siblingState 17797 * @param {Ref<Boolean>} $lastInvalidState - the last invalid state 17798 * @param {Ref<Number>} $lastCommittedOn - the last time $commit was called 17799 * @return {{ $params: *, $message: Ref<String>, $pending: Ref<Boolean>, $invalid: Ref<Boolean>, $response: Ref<*>, $unwatch: WatchStopHandle }} 17800 */ 17801 17802 17803function createValidatorResult(rule, model, $dirty, config, instance, validatorName, propertyKey, propertyPath, siblingState, $lastInvalidState, $lastCommittedOn) { 17804 const $pending = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)(false); 17805 const $params = rule.$params || {}; 17806 const $response = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)(null); 17807 let $invalid; 17808 let $unwatch; 17809 17810 if (rule.$async) { 17811 ({ 17812 $invalid, 17813 $unwatch 17814 } = createAsyncResult(rule.$validator, model, $pending, $dirty, config, $response, instance, rule.$watchTargets, siblingState, $lastInvalidState, $lastCommittedOn)); 17815 } else { 17816 ({ 17817 $invalid, 17818 $unwatch 17819 } = createSyncResult(rule.$validator, model, $dirty, config, $response, instance, siblingState, $lastInvalidState)); 17820 } 17821 17822 const message = rule.$message; 17823 const $message = isFunction(message) ? (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => message(unwrapObj({ 17824 $pending, 17825 $invalid, 17826 $params: unwrapObj($params), 17827 // $params can hold refs, so we unwrap them for easy access 17828 $model: model, 17829 $response, 17830 $validator: validatorName, 17831 $propertyPath: propertyPath, 17832 $property: propertyKey 17833 }))) : message || ''; 17834 return { 17835 $message, 17836 $params, 17837 $pending, 17838 $invalid, 17839 $response, 17840 $unwatch 17841 }; 17842} 17843 17844/** 17845 * Sorts a validation definition into rules, configs and nested validators. 17846 * @param {Object<NormalizedValidator|Function>} validationsRaw 17847 * @return {{ rules: Object<NormalizedValidator>, nestedValidators: Object, config: GlobalConfig }} 17848 */ 17849 17850function sortValidations() { 17851 let validationsRaw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 17852 const validations = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(validationsRaw); 17853 const validationKeys = Object.keys(validations); 17854 const rules = {}; 17855 const nestedValidators = {}; 17856 const config = {}; 17857 let validationGroups = null; 17858 validationKeys.forEach(key => { 17859 const v = validations[key]; 17860 17861 switch (true) { 17862 // If it is already normalized, use it 17863 case isFunction(v.$validator): 17864 rules[key] = v; 17865 break; 17866 // If it is just a function, normalize it first 17867 // into { $validator: <Fun> } 17868 17869 case isFunction(v): 17870 rules[key] = { 17871 $validator: v 17872 }; 17873 break; 17874 17875 case key === '$validationGroups': 17876 validationGroups = v; 17877 break; 17878 // Catch $-prefixed properties as config 17879 17880 case key.startsWith('$'): 17881 config[key] = v; 17882 break; 17883 // If it doesnât match any of the above, 17884 // treat as nestedValidators state property 17885 17886 default: 17887 nestedValidators[key] = v; 17888 } 17889 }); 17890 return { 17891 rules, 17892 nestedValidators, 17893 config, 17894 validationGroups 17895 }; 17896} 17897 17898function _empty() {} 17899 17900const ROOT_PATH = '__root'; 17901/** @typedef {import('vue-demi').ComponentPublicInstance} VueInstance */ 17902 17903/** @typedef {import('vue-demi').ComputedRef} ComputedRef */ 17904 17905/** @typedef {import('vue-demi').UnwrapRef} UnwrapRef */ 17906 17907/** @typedef {import('vue-demi').WatchStopHandle} WatchStopHandle */ 17908 17909/** @typedef {import('vue-demi').WritableComputedRef} WritableComputedRef */ 17910 17911/** @typedef {import('vue-demi').UnwrapNestedRefs} UnwrapNestedRefs */ 17912 17913/** 17914 * @typedef NormalizedValidator 17915 * @property {Validator} $validator 17916 * @property {String | Ref<String> | function(*): string} [$message] 17917 * @property {Object | Ref<Object>} [$params] 17918 * @property {Object | Ref<Object>} [$async] 17919 * @property {Ref<*>[]} [$watchTargets] 17920 */ 17921 17922/** 17923 * Raw validator function, before being normalized 17924 * Can return a Promise or a {@see ValidatorResponse} 17925 * @typedef {function(*): ((Promise<ValidatorResponse> | ValidatorResponse))} Validator 17926 */ 17927 17928/** 17929 * @typedef ErrorObject 17930 * @property {Ref<String>} $message - Reactive error message 17931 * @property {Ref<Object>} $params - Params passed from withParams 17932 * @property {Ref<Boolean>} $pending - If validation is pending 17933 * @property {String} $property - State key 17934 * @property {String} $propertyPath - Dot notation path to state 17935 * @property {String} $validator - Validator name 17936 * @property {String} $uid - Unique identifier 17937 */ 17938 17939/** 17940 * @typedef ValidationResult 17941 * @property {Ref<Boolean>} $pending 17942 * @property {Ref<Boolean>} $dirty 17943 * @property {Ref<Boolean>} $invalid 17944 * @property {Ref<Boolean>} $error 17945 * @property {Ref<String>} $path 17946 * @property {Function} $touch 17947 * @property {Function} $reset 17948 * @property {ComputedRef<ErrorObject[]>} $errors 17949 * @property {ComputedRef<ErrorObject[]>} $silentErrors 17950 * @property {Function} $commit 17951 */ 17952 17953/** 17954 * Creates the main Validation Results object for a state tree 17955 * Walks the tree's top level branches 17956 * @param {Object<NormalizedValidator>} rules - Rules for the current state tree 17957 * @param {Object} model - Current state value 17958 * @param {String} key - Key for the current state tree 17959 * @param {ResultsStorage} [resultsCache] - A cache map of all the validators 17960 * @param {String} [path] - the current property path 17961 * @param {GlobalConfig} [config] - the config object 17962 * @param {VueInstance} instance 17963 * @param {ComputedRef<Object>} externalResults 17964 * @param {Object} siblingState 17965 * @return {ValidationResult | {}} 17966 */ 17967 17968function _call(body, then, direct) { 17969 if (direct) { 17970 return then ? then(body()) : body(); 17971 } 17972 17973 try { 17974 var result = Promise.resolve(body()); 17975 return then ? result.then(then) : result; 17976 } catch (e) { 17977 return Promise.reject(e); 17978 } 17979} 17980/** 17981 * Collects the validation results of all nested state properties 17982 * @param {Object<NormalizedValidator|Function>} validations - The validation 17983 * @param {Object} nestedState - Current state 17984 * @param {String} path - Path to current property 17985 * @param {ResultsStorage} resultsCache - Validations cache map 17986 * @param {GlobalConfig} config - The config object 17987 * @param {VueInstance} instance - The current Vue instance 17988 * @param {ComputedRef<object>} nestedExternalResults - The external results for this nested collection 17989 * @return {Object<string, VuelidateState>} 17990 */ 17991 17992 17993function _callIgnored(body, direct) { 17994 return _call(body, _empty, direct); 17995} 17996 17997function _invoke(body, then) { 17998 var result = body(); 17999 18000 if (result && result.then) { 18001 return result.then(then); 18002 } 18003 18004 return then(result); 18005} 18006 18007function _async(f) { 18008 return function () { 18009 for (var args = [], i = 0; i < arguments.length; i++) { 18010 args[i] = arguments[i]; 18011 } 18012 18013 try { 18014 return Promise.resolve(f.apply(this, args)); 18015 } catch (e) { 18016 return Promise.reject(e); 18017 } 18018 }; 18019} 18020 18021function createValidationResults(rules, model, key, resultsCache, path, config, instance, externalResults, siblingState) { 18022 // collect the property keys 18023 const ruleKeys = Object.keys(rules); 18024 const cachedResult = resultsCache.get(path, rules); 18025 const $dirty = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)(false); // state for the $rewardEarly option 18026 18027 /** The last invalid state of this property */ 18028 18029 const $lastInvalidState = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)(false); 18030 /** The last time $commit was called. Used to re-trigger async calls */ 18031 18032 const $lastCommittedOn = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)(0); 18033 18034 if (cachedResult) { 18035 // if the rules are the same as before, use the cached results 18036 if (!cachedResult.$partial) return cachedResult; // remove old watchers 18037 18038 cachedResult.$unwatch(); // use the `$dirty.value`, so we dont save references by accident 18039 18040 $dirty.value = cachedResult.$dirty.value; 18041 } 18042 18043 const result = { 18044 // restore $dirty from cache 18045 $dirty, 18046 $path: path, 18047 $touch: () => { 18048 if (!$dirty.value) $dirty.value = true; 18049 }, 18050 $reset: () => { 18051 if ($dirty.value) $dirty.value = false; 18052 }, 18053 $commit: () => {} 18054 }; 18055 /** 18056 * If there are no validation rules, it is most likely 18057 * a top level state, aka root 18058 */ 18059 18060 if (!ruleKeys.length) { 18061 // if there are cached results, we should overwrite them with the new ones 18062 cachedResult && resultsCache.set(path, rules, result); 18063 return result; 18064 } 18065 18066 ruleKeys.forEach(ruleKey => { 18067 result[ruleKey] = createValidatorResult(rules[ruleKey], model, result.$dirty, config, instance, ruleKey, key, path, siblingState, $lastInvalidState, $lastCommittedOn); 18068 }); 18069 result.$externalResults = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 18070 if (!externalResults.value) return []; 18071 return [].concat(externalResults.value).map((stringError, index) => ({ 18072 $propertyPath: path, 18073 $property: key, 18074 $validator: '$externalResults', 18075 $uid: `${path}-externalResult-${index}`, 18076 $message: stringError, 18077 $params: {}, 18078 $response: null, 18079 $pending: false 18080 })); 18081 }); 18082 result.$invalid = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 18083 const r = ruleKeys.some(ruleKey => (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(result[ruleKey].$invalid)); // cache the last invalid state 18084 18085 $lastInvalidState.value = r; 18086 return !!result.$externalResults.value.length || r; 18087 }); 18088 result.$pending = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => ruleKeys.some(ruleKey => (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(result[ruleKey].$pending))); 18089 result.$error = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => result.$dirty.value ? result.$pending.value || result.$invalid.value : false); 18090 result.$silentErrors = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => ruleKeys.filter(ruleKey => (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(result[ruleKey].$invalid)).map(ruleKey => { 18091 const res = result[ruleKey]; 18092 return (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.reactive)({ 18093 $propertyPath: path, 18094 $property: key, 18095 $validator: ruleKey, 18096 $uid: `${path}-${ruleKey}`, 18097 $message: res.$message, 18098 $params: res.$params, 18099 $response: res.$response, 18100 $pending: res.$pending 18101 }); 18102 }).concat(result.$externalResults.value)); 18103 result.$errors = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => result.$dirty.value ? result.$silentErrors.value : []); 18104 18105 result.$unwatch = () => ruleKeys.forEach(ruleKey => { 18106 result[ruleKey].$unwatch(); 18107 }); 18108 18109 result.$commit = () => { 18110 $lastInvalidState.value = true; 18111 $lastCommittedOn.value = Date.now(); 18112 }; 18113 18114 resultsCache.set(path, rules, result); 18115 return result; 18116} 18117 18118function collectNestedValidationResults(validations, nestedState, path, resultsCache, config, instance, nestedExternalResults) { 18119 const nestedValidationKeys = Object.keys(validations); // if we have no state, return empty object 18120 18121 if (!nestedValidationKeys.length) return {}; 18122 return nestedValidationKeys.reduce((results, nestedKey) => { 18123 // build validation results for nested state 18124 results[nestedKey] = setValidations({ 18125 validations: validations[nestedKey], 18126 state: nestedState, 18127 key: nestedKey, 18128 parentKey: path, 18129 resultsCache, 18130 globalConfig: config, 18131 instance, 18132 externalResults: nestedExternalResults 18133 }); 18134 return results; 18135 }, {}); 18136} 18137/** 18138 * Generates the Meta fields from the results 18139 * @param {ValidationResult|{}} results 18140 * @param {Object.<string, VuelidateState>} nestedResults 18141 * @param {Object.<string, ValidationResult>} childResults 18142 * @return {{$anyDirty: Ref<Boolean>, $error: Ref<Boolean>, $invalid: Ref<Boolean>, $errors: Ref<ErrorObject[]>, $dirty: Ref<Boolean>, $touch: Function, $reset: Function }} 18143 */ 18144 18145 18146function createMetaFields(results, nestedResults, childResults) { 18147 const allResults = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => [nestedResults, childResults].filter(res => res).reduce((allRes, res) => { 18148 return allRes.concat(Object.values((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(res))); 18149 }, [])); // returns `$dirty` as true, if all children are dirty 18150 18151 const $dirty = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)({ 18152 get() { 18153 return results.$dirty.value || (allResults.value.length ? allResults.value.every(r => r.$dirty) : false); 18154 }, 18155 18156 set(v) { 18157 results.$dirty.value = v; 18158 } 18159 18160 }); 18161 const $silentErrors = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 18162 // current state level errors, fallback to empty array if root 18163 const modelErrors = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(results.$silentErrors) || []; // collect all nested and child $silentErrors 18164 18165 const nestedErrors = allResults.value.filter(result => ((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(result).$silentErrors || []).length).reduce((errors, result) => { 18166 return errors.concat(...result.$silentErrors); 18167 }, []); // merge the $silentErrors 18168 18169 return modelErrors.concat(nestedErrors); 18170 }); 18171 const $errors = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 18172 // current state level errors, fallback to empty array if root 18173 const modelErrors = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(results.$errors) || []; // collect all nested and child $errors 18174 18175 const nestedErrors = allResults.value.filter(result => ((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(result).$errors || []).length).reduce((errors, result) => { 18176 return errors.concat(...result.$errors); 18177 }, []); // merge the $errors 18178 18179 return modelErrors.concat(nestedErrors); 18180 }); 18181 const $invalid = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => // if any of the nested values is invalid 18182 allResults.value.some(r => r.$invalid) || // or if the current state is invalid 18183 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(results.$invalid) || // fallback to false if is root 18184 false); 18185 const $pending = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => // if any of the nested values is pending 18186 allResults.value.some(r => (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(r.$pending)) || // if any of the current state validators is pending 18187 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(results.$pending) || // fallback to false if is root 18188 false); 18189 const $anyDirty = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => allResults.value.some(r => r.$dirty) || allResults.value.some(r => r.$anyDirty) || $dirty.value); 18190 const $error = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => $dirty.value ? $pending.value || $invalid.value : false); 18191 18192 const $touch = () => { 18193 // call the root $touch 18194 results.$touch(); // call all nested level $touch 18195 18196 allResults.value.forEach(result => { 18197 result.$touch(); 18198 }); 18199 }; 18200 18201 const $commit = () => { 18202 // call the root $touch 18203 results.$commit(); // call all nested level $touch 18204 18205 allResults.value.forEach(result => { 18206 result.$commit(); 18207 }); 18208 }; 18209 18210 const $reset = () => { 18211 // reset the root $dirty state 18212 results.$reset(); // reset all the children $dirty states 18213 18214 allResults.value.forEach(result => { 18215 result.$reset(); 18216 }); 18217 }; // Ensure that if all child and nested results are $dirty, this also becomes $dirty 18218 18219 18220 if (allResults.value.length && allResults.value.every(nr => nr.$dirty)) $touch(); 18221 return { 18222 $dirty, 18223 $errors, 18224 $invalid, 18225 $anyDirty, 18226 $error, 18227 $pending, 18228 $touch, 18229 $reset, 18230 $silentErrors, 18231 $commit 18232 }; 18233} 18234/** 18235 * @typedef VuelidateState 18236 * @property {WritableComputedRef<any>} $model 18237 * @property {ComputedRef<Boolean>} $dirty 18238 * @property {ComputedRef<Boolean>} $error 18239 * @property {ComputedRef<ErrorObject[]>} $errors 18240 * @property {ComputedRef<Boolean>} $invalid 18241 * @property {ComputedRef<Boolean>} $anyDirty 18242 * @property {ComputedRef<Boolean>} $pending 18243 * @property {Function} $touch 18244 * @property {Function} $reset 18245 * @property {String} $path 18246 * @property {ComputedRef<ErrorObject[]>} $silentErrors 18247 * @property {Function} [$validate] 18248 * @property {Function} [$getResultsForChild] 18249 * @property {Object.<string, VuelidateState>} 18250 */ 18251 18252/** 18253 * Main Vuelidate bootstrap function. 18254 * Used both for Composition API in `setup` and for Global App usage. 18255 * Used to collect validation state, when walking recursively down the state tree 18256 * @param {Object} params 18257 * @param {Object<NormalizedValidator|Function>} params.validations 18258 * @param {Object} params.state 18259 * @param {String} [params.key] - Current state property key. Used when being called on nested items 18260 * @param {String} [params.parentKey] - Parent state property key. Used when being called recursively 18261 * @param {Object<string, ValidationResult>} [params.childResults] - Used to collect child results. 18262 * @param {ResultsStorage} params.resultsCache - The cached validation results 18263 * @param {VueInstance} params.instance - The current Vue instance 18264 * @param {GlobalConfig} params.globalConfig - The validation config, passed to this setValidations instance. 18265 * @param {UnwrapNestedRefs<object> | Ref<Object>} params.externalResults - External validation results 18266 * @return {UnwrapNestedRefs<VuelidateState>} 18267 */ 18268 18269 18270function setValidations(_ref) { 18271 /** 18272 * Executes the validators and returns the result. 18273 * @return {Promise<boolean>} 18274 */ 18275 const $validate = _async(function () { 18276 $touch(); 18277 return _invoke(function () { 18278 if (mergedConfig.$rewardEarly) { 18279 $commit(); // await the watchers 18280 18281 return _callIgnored(vue_demi__WEBPACK_IMPORTED_MODULE_0__.nextTick); 18282 } 18283 }, function () { 18284 // await the watchers 18285 return _call(vue_demi__WEBPACK_IMPORTED_MODULE_0__.nextTick, function () { 18286 return new Promise(resolve => { 18287 // return whether it is valid or not 18288 if (!$pending.value) return resolve(!$invalid.value); 18289 const unwatch = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.watch)($pending, () => { 18290 resolve(!$invalid.value); 18291 unwatch(); 18292 }); 18293 }); 18294 }); 18295 }); 18296 }); 18297 /** 18298 * Returns a child component's results, based on registration name 18299 * @param {string} key 18300 * @return {VuelidateState} 18301 */ 18302 18303 18304 let { 18305 validations, 18306 state, 18307 key, 18308 parentKey, 18309 childResults, 18310 resultsCache, 18311 globalConfig = {}, 18312 instance, 18313 externalResults 18314 } = _ref; 18315 const path = parentKey ? `${parentKey}.${key}` : key; // Sort out the validation object into: 18316 // â rules = validators for current state tree fragment 18317 // â nestedValidators = nested state fragments keys that might contain more validators 18318 // â config = configuration properties that affect this state fragment 18319 18320 const { 18321 rules, 18322 nestedValidators, 18323 config, 18324 validationGroups 18325 } = sortValidations(validations); 18326 const mergedConfig = Object.assign({}, globalConfig, config); // create protected state for cases when the state branch does not exist yet. 18327 // This protects when using the OptionsAPI as the data is bound after the setup method 18328 18329 const nestedState = key ? (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 18330 const s = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(state); 18331 return s ? (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(s[key]) : undefined; 18332 }) : state; // cache the external results, so we can revert back to them 18333 18334 const cachedExternalResults = Object.assign({}, (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(externalResults) || {}); 18335 const nestedExternalResults = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 18336 const results = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(externalResults); 18337 if (!key) return results; 18338 return results ? (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(results[key]) : undefined; 18339 }); // Use rules for the current state fragment and validate it 18340 18341 const results = createValidationResults(rules, nestedState, key, resultsCache, path, mergedConfig, instance, nestedExternalResults, state); // Use nested keys to repeat the process 18342 // *WARN*: This is recursive 18343 18344 const nestedResults = collectNestedValidationResults(nestedValidators, nestedState, path, resultsCache, mergedConfig, instance, nestedExternalResults); 18345 const $validationGroups = {}; 18346 18347 if (validationGroups) { 18348 Object.entries(validationGroups).forEach(_ref2 => { 18349 let [key, group] = _ref2; 18350 $validationGroups[key] = { 18351 $invalid: gatherBooleanGroupProperties(group, nestedResults, '$invalid'), 18352 $error: gatherBooleanGroupProperties(group, nestedResults, '$error'), 18353 $pending: gatherBooleanGroupProperties(group, nestedResults, '$pending'), 18354 $errors: gatherArrayGroupProperties(group, nestedResults, '$errors'), 18355 $silentErrors: gatherArrayGroupProperties(group, nestedResults, '$silentErrors') 18356 }; 18357 }); 18358 } // Collect and merge this level validation results 18359 // with all nested validation results 18360 18361 18362 const { 18363 $dirty, 18364 $errors, 18365 $invalid, 18366 $anyDirty, 18367 $error, 18368 $pending, 18369 $touch, 18370 $reset, 18371 $silentErrors, 18372 $commit 18373 } = createMetaFields(results, nestedResults, childResults); 18374 /** 18375 * If we have no `key`, this is the top level state 18376 * We dont need `$model` there. 18377 */ 18378 18379 const $model = key ? (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)({ 18380 get: () => (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(nestedState), 18381 set: val => { 18382 $dirty.value = true; 18383 const s = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(state); 18384 const external = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(externalResults); 18385 18386 if (external) { 18387 external[key] = cachedExternalResults[key]; 18388 } 18389 18390 if ((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isRef)(s[key])) { 18391 s[key].value = val; 18392 } else { 18393 s[key] = val; 18394 } 18395 } 18396 }) : null; 18397 18398 if (key && mergedConfig.$autoDirty) { 18399 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.watch)(nestedState, () => { 18400 if (!$dirty.value) $touch(); 18401 const external = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(externalResults); 18402 18403 if (external) { 18404 external[key] = cachedExternalResults[key]; 18405 } 18406 }, { 18407 flush: 'sync' 18408 }); 18409 } 18410 18411 function $getResultsForChild(key) { 18412 return (childResults.value || {})[key]; 18413 } 18414 18415 function $clearExternalResults() { 18416 if ((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isRef)(externalResults)) { 18417 externalResults.value = cachedExternalResults; 18418 } else { 18419 // if the external results state was empty, we need to delete every property, one by one 18420 if (Object.keys(cachedExternalResults).length === 0) { 18421 Object.keys(externalResults).forEach(k => { 18422 delete externalResults[k]; 18423 }); 18424 } else { 18425 // state was not empty, so we just assign it back into the current state 18426 Object.assign(externalResults, cachedExternalResults); 18427 } 18428 } 18429 } 18430 18431 return (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.reactive)(Object.assign({}, results, { 18432 // NOTE: The order here is very important, since we want to override 18433 // some of the *results* meta fields with the collective version of it 18434 // that includes the results of nested state validation results 18435 $model, 18436 $dirty, 18437 $error, 18438 $errors, 18439 $invalid, 18440 $anyDirty, 18441 $pending, 18442 $touch, 18443 $reset, 18444 $path: path || ROOT_PATH, 18445 $silentErrors, 18446 $validate, 18447 $commit 18448 }, childResults && { 18449 $getResultsForChild, 18450 $clearExternalResults, 18451 $validationGroups 18452 }, nestedResults)); 18453} 18454 18455class ResultsStorage { 18456 constructor() { 18457 this.storage = new Map(); 18458 } 18459 /** 18460 * Stores a validation result, and its rules by its path 18461 * @param {String} path 18462 * @param {Object<NormalizedValidator>} rules 18463 * @param {ValidationResult} result 18464 */ 18465 18466 18467 set(path, rules, result) { 18468 this.storage.set(path, { 18469 rules, 18470 result 18471 }); 18472 } 18473 /** 18474 * Check if the stored `results` for the provided `path` have the same `rules` compared to 'storedRules' 18475 * @param {String} path 18476 * @param {Object<NormalizedValidator>} rules 18477 * @param {Object<NormalizedValidator>} storedRules 18478 * @return {Boolean} 18479 */ 18480 18481 18482 checkRulesValidity(path, rules, storedRules) { 18483 const storedRulesKeys = Object.keys(storedRules); 18484 const newRulesKeys = Object.keys(rules); 18485 if (newRulesKeys.length !== storedRulesKeys.length) return false; 18486 const hasAllValidators = newRulesKeys.every(ruleKey => storedRulesKeys.includes(ruleKey)); 18487 if (!hasAllValidators) return false; 18488 return newRulesKeys.every(ruleKey => { 18489 if (!rules[ruleKey].$params) return true; 18490 return Object.keys(rules[ruleKey].$params).every(paramKey => { 18491 // make sure to unwrap before comparing 18492 return (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(storedRules[ruleKey].$params[paramKey]) === (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(rules[ruleKey].$params[paramKey]); 18493 }); 18494 }); 18495 } 18496 /** 18497 * Returns the matched result if catche is valid 18498 * @param {String} path 18499 * @param {Object<NormalizedValidator>} rules 18500 * @return {{$partial: boolean, $dirty: Ref<Boolean>, $unwatch: function}|undefined|ValidationResult} 18501 */ 18502 18503 18504 get(path, rules) { 18505 const storedRuleResultPair = this.storage.get(path); 18506 if (!storedRuleResultPair) return undefined; 18507 const { 18508 rules: storedRules, 18509 result 18510 } = storedRuleResultPair; 18511 const isValidCache = this.checkRulesValidity(path, rules, storedRules); 18512 const $unwatch = result.$unwatch ? result.$unwatch : () => ({}); 18513 if (!isValidCache) return { 18514 $dirty: result.$dirty, 18515 $partial: true, 18516 $unwatch 18517 }; 18518 return result; 18519 } 18520 18521} 18522 18523const CollectFlag = { 18524 COLLECT_ALL: true, 18525 COLLECT_NONE: false 18526}; 18527const VuelidateInjectChildResults = Symbol('vuelidate#injectChildResults'); 18528const VuelidateRemoveChildResults = Symbol('vuelidate#removeChildResults'); 18529/** 18530 * Create helpers to collect validation state from child components 18531 * @param {Object} params 18532 * @param {String | Number | Boolean} params.$scope - Parent component scope 18533 * @return {{sendValidationResultsToParent: function[], childResults: ComputedRef<Object>, removeValidationResultsFromParent: function[]}} 18534 */ 18535 18536function nestedValidations(_ref) { 18537 let { 18538 $scope, 18539 instance 18540 } = _ref; 18541 const childResultsRaw = {}; 18542 const childResultsKeys = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)([]); 18543 const childResults = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => childResultsKeys.value.reduce((results, key) => { 18544 results[key] = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(childResultsRaw[key]); 18545 return results; 18546 }, {})); 18547 /** 18548 * Allows children to send validation data up to their parent. 18549 * @param {Object} results - the results 18550 * @param {Object} args 18551 * @param {String} args.$registerAs - the $registeredAs key 18552 * @param {String | Number | Boolean} args.$scope - the $scope key 18553 */ 18554 18555 function injectChildResultsIntoParent(results, _ref2) { 18556 let { 18557 $registerAs: key, 18558 $scope: childScope, 18559 $stopPropagation 18560 } = _ref2; 18561 if ($stopPropagation || $scope === CollectFlag.COLLECT_NONE || childScope === CollectFlag.COLLECT_NONE || $scope !== CollectFlag.COLLECT_ALL && $scope !== childScope) return; 18562 childResultsRaw[key] = results; 18563 childResultsKeys.value.push(key); 18564 } // combine with other `injectChildResultsIntoParent` from vuelidate instances in this Vue component instance 18565 18566 18567 instance.__vuelidateInjectInstances = [].concat(instance.__vuelidateInjectInstances || [], injectChildResultsIntoParent); 18568 /** 18569 * Allows children to remove the validation data from their parent, before getting destroyed. 18570 * @param {String} key - the registeredAs key 18571 */ 18572 18573 function removeChildResultsFromParent(key) { 18574 // remove the key 18575 childResultsKeys.value = childResultsKeys.value.filter(childKey => childKey !== key); // remove the stored data for the key 18576 18577 delete childResultsRaw[key]; 18578 } // combine with other `removeChildResultsFromParent` from vuelidate instances in this Vue component instance 18579 18580 18581 instance.__vuelidateRemoveInstances = [].concat(instance.__vuelidateRemoveInstances || [], removeChildResultsFromParent); // inject the `injectChildResultsIntoParent` method, into the current scope 18582 18583 const sendValidationResultsToParent = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.inject)(VuelidateInjectChildResults, []); // provide to all of its children the send results to parent function 18584 18585 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.provide)(VuelidateInjectChildResults, instance.__vuelidateInjectInstances); 18586 const removeValidationResultsFromParent = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.inject)(VuelidateRemoveChildResults, []); // provide to all of its children the remove results function 18587 18588 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.provide)(VuelidateRemoveChildResults, instance.__vuelidateRemoveInstances); 18589 return { 18590 childResults, 18591 sendValidationResultsToParent, 18592 removeValidationResultsFromParent 18593 }; 18594} 18595 18596/** 18597 * Helper proxy for instance property access. It makes every reference 18598 * reactive for the validation function 18599 * @param target 18600 * @return {*|ComputedRef<*>} 18601 */ 18602 18603function ComputedProxyFactory(target) { 18604 return new Proxy(target, { 18605 get(target, prop) { 18606 return typeof target[prop] === 'object' ? ComputedProxyFactory(target[prop]) : (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => target[prop]); 18607 } 18608 18609 }); 18610} 18611 18612/** 18613 * @typedef GlobalConfig 18614 * @property {String} [$registerAs] - Config Object 18615 * @property {String | Number | Symbol} [$scope] - A scope to limit child component registration 18616 * @property {Boolean} [$stopPropagation] - Tells a Vue component to stop sending its results up to the parent 18617 * @property {Ref<Object>} [$externalResults] - External error messages, like from server validation. 18618 * @property {Boolean} [$autoDirty] - Should the form watch for state changed, and automatically set `$dirty` to true. 18619 * @property {Boolean} [$lazy] - Should the validations be lazy, and run only after they are dirty 18620 * @property {Boolean} [$rewardEarly] - Once valid, re-runs property validators only on manual calls of $commit 18621 */ 18622 18623/** 18624 * Composition API compatible Vuelidate 18625 * Use inside the `setup` lifecycle hook 18626 * @param {Object | GlobalConfig} [validations] - Validations Object or the globalConfig. 18627 * @param {Object} [state] - State object - required if `validations` is a validation object. 18628 * @param {GlobalConfig} [globalConfig] - Config Object 18629 * @return {ComputedRef<*>} 18630 */ 18631 18632let uid = 0; 18633function useVuelidate(validations, state) { 18634 var _getCurrentInstance; 18635 18636 let globalConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 18637 18638 // if we pass only one argument, its most probably the globalConfig. 18639 // This use case is so parents can just collect results of child forms. 18640 if (arguments.length === 1) { 18641 globalConfig = validations; 18642 validations = undefined; 18643 state = undefined; 18644 } 18645 18646 let { 18647 $registerAs, 18648 $scope = CollectFlag.COLLECT_ALL, 18649 $stopPropagation, 18650 $externalResults, 18651 currentVueInstance 18652 } = globalConfig; 18653 const instance = currentVueInstance || ((_getCurrentInstance = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy); 18654 const componentOptions = instance ? instance.$options : {}; // if there is no registration name, add one. 18655 18656 if (!$registerAs) { 18657 uid += 1; 18658 $registerAs = `_vuelidate_${uid}`; 18659 } 18660 18661 const validationResults = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)({}); 18662 const resultsCache = new ResultsStorage(); 18663 const { 18664 childResults, 18665 sendValidationResultsToParent, 18666 removeValidationResultsFromParent 18667 } = instance ? nestedValidations({ 18668 $scope, 18669 instance 18670 }) : { 18671 childResults: (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)({}) 18672 }; // Options API 18673 18674 if (!validations && componentOptions.validations) { 18675 const rules = componentOptions.validations; 18676 state = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.ref)({}); 18677 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount)(() => { 18678 // Delay binding state to validations defined with the Options API until mounting, when the data 18679 // has been attached to the component instance. From that point on it will be reactive. 18680 state.value = instance; 18681 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.watch)(() => isFunction(rules) ? rules.call(state.value, new ComputedProxyFactory(state.value)) : rules, validations => { 18682 validationResults.value = setValidations({ 18683 validations, 18684 state, 18685 childResults, 18686 resultsCache, 18687 globalConfig, 18688 instance, 18689 externalResults: $externalResults || instance.vuelidateExternalResults 18690 }); 18691 }, { 18692 immediate: true 18693 }); 18694 }); 18695 globalConfig = componentOptions.validationsConfig || globalConfig; 18696 } else { 18697 const validationsWatchTarget = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.isRef)(validations) || isProxy(validations) ? validations // wrap plain objects in a reactive, so we can track changes if they have computed in them. 18698 : (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.reactive)(validations || {}); 18699 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.watch)(validationsWatchTarget, newValidationRules => { 18700 validationResults.value = setValidations({ 18701 validations: newValidationRules, 18702 state, 18703 childResults, 18704 resultsCache, 18705 globalConfig, 18706 instance: instance !== null && instance !== void 0 ? instance : {}, 18707 externalResults: $externalResults 18708 }); 18709 }, { 18710 immediate: true 18711 }); 18712 } 18713 18714 if (instance) { 18715 // send all the data to the parent when the function is invoked inside setup. 18716 sendValidationResultsToParent.forEach(f => f(validationResults, { 18717 $registerAs, 18718 $scope, 18719 $stopPropagation 18720 })); // before this component is destroyed, remove all the data from the parent. 18721 18722 (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount)(() => removeValidationResultsFromParent.forEach(f => f($registerAs))); 18723 } 18724 18725 return (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.computed)(() => { 18726 return Object.assign({}, (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(validationResults.value), childResults.value); 18727 }); 18728} 18729 18730 18731 18732 18733/***/ }), 18734
vendor: 29,494 bytes, lines 18735-19789
18735/***/ "./node_modules/@vuelidate/validators/dist/index.esm.js": 18736/*!**************************************************************!*\ 18737 !*** ./node_modules/@vuelidate/validators/dist/index.esm.js ***! 18738 \**************************************************************/ 18739/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 18740 18741"use strict"; 18742__webpack_require__.r(__webpack_exports__); 18743/* harmony export */ __webpack_require__.d(__webpack_exports__, { 18744/* harmony export */ "alpha": function() { return /* binding */ alpha; }, 18745/* harmony export */ "alphaNum": function() { return /* binding */ alphaNum; }, 18746/* harmony export */ "and": function() { return /* binding */ and; }, 18747/* harmony export */ "between": function() { return /* binding */ between; }, 18748/* harmony export */ "createI18nMessage": function() { return /* binding */ createI18nMessage; }, 18749/* harmony export */ "decimal": function() { return /* binding */ decimal; }, 18750/* harmony export */ "email": function() { return /* binding */ email; }, 18751/* harmony export */ "helpers": function() { return /* binding */ common; }, 18752/* harmony export */ "integer": function() { return /* binding */ integer; }, 18753/* harmony export */ "ipAddress": function() { return /* binding */ ipAddress; }, 18754/* harmony export */ "macAddress": function() { return /* binding */ macAddress; }, 18755/* harmony export */ "maxLength": function() { return /* binding */ maxLength; }, 18756/* harmony export */ "maxValue": function() { return /* binding */ maxValue; }, 18757/* harmony export */ "minLength": function() { return /* binding */ minLength; }, 18758/* harmony export */ "minValue": function() { return /* binding */ minValue; }, 18759/* harmony export */ "not": function() { return /* binding */ not; }, 18760/* harmony export */ "numeric": function() { return /* binding */ numeric; }, 18761/* harmony export */ "or": function() { return /* binding */ or; }, 18762/* harmony export */ "required": function() { return /* binding */ required; }, 18763/* harmony export */ "requiredIf": function() { return /* binding */ requiredIf; }, 18764/* harmony export */ "requiredUnless": function() { return /* binding */ requiredUnless; }, 18765/* harmony export */ "sameAs": function() { return /* binding */ sameAs; }, 18766/* harmony export */ "url": function() { return /* binding */ url; } 18767/* harmony export */ }); 18768/* harmony import */ var vue_demi__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue-demi */ "./node_modules/vue-demi/lib/index.mjs"); 18769 18770 18771function isFunction(val) { 18772 return typeof val === 'function'; 18773} 18774function isObject(o) { 18775 return o !== null && typeof o === 'object' && !Array.isArray(o); 18776} 18777/** 18778 * Returns a standard ValidatorObject 18779 * Wraps a plain function into a ValidatorObject 18780 * @param {NormalizedValidator|Function} validator 18781 * @return {NormalizedValidator} 18782 */ 18783 18784function normalizeValidatorObject(validator) { 18785 return isFunction(validator.$validator) ? Object.assign({}, validator) : { 18786 $validator: validator 18787 }; 18788} 18789function isPromise(object) { 18790 return isObject(object) && isFunction(object.then); 18791} 18792/** 18793 * Unwraps a ValidatorResponse object, into a boolean. 18794 * @param {ValidatorResponse} result 18795 * @return {boolean} 18796 */ 18797 18798function unwrapValidatorResponse(result) { 18799 if (typeof result === 'object') return result.$valid; 18800 return result; 18801} 18802/** 18803 * Unwraps a `NormalizedValidator` object, returning its validator function. 18804 * @param {NormalizedValidator | Function} validator 18805 * @return {function} 18806 */ 18807 18808function unwrapNormalizedValidator(validator) { 18809 return validator.$validator || validator; 18810} 18811 18812/** 18813 * Allows attaching parameters to a validator 18814 * @param {Object} $params 18815 * @param {NormalizedValidator|Function} $validator 18816 * @return {NormalizedValidator} 18817 */ 18818 18819function withParams($params, $validator) { 18820 if (!isObject($params)) throw new Error(`[@vuelidate/validators]: First parameter to "withParams" should be an object, provided ${typeof $params}`); 18821 if (!isObject($validator) && !isFunction($validator)) throw new Error(`[@vuelidate/validators]: Validator must be a function or object with $validator parameter`); 18822 const validatorObj = normalizeValidatorObject($validator); 18823 validatorObj.$params = Object.assign({}, validatorObj.$params || {}, $params); 18824 return validatorObj; 18825} 18826 18827/** 18828 * @callback MessageCallback 18829 * @param {Object} params 18830 * @return String 18831 */ 18832 18833/** 18834 * Attaches a message to a validator 18835 * @param {MessageCallback | String} $message 18836 * @param {NormalizedValidator|Function} $validator 18837 * @return {NormalizedValidator} 18838 */ 18839 18840function withMessage($message, $validator) { 18841 if (!isFunction($message) && typeof (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)($message) !== 'string') throw new Error(`[@vuelidate/validators]: First parameter to "withMessage" should be string or a function returning a string, provided ${typeof $message}`); 18842 if (!isObject($validator) && !isFunction($validator)) throw new Error(`[@vuelidate/validators]: Validator must be a function or object with $validator parameter`); 18843 const validatorObj = normalizeValidatorObject($validator); 18844 validatorObj.$message = $message; 18845 return validatorObj; 18846} 18847 18848/** 18849 * @typedef {function(*): Promise<boolean|ValidatorResponse>} asyncValidator 18850 */ 18851 18852/** 18853 * @typedef {Ref<*>[]|function(*): *} watchTargets 18854 */ 18855 18856/** 18857 * Wraps validators that returns a Promise. 18858 * @param {asyncValidator} $validator 18859 * @param {watchTargets} $watchTargets 18860 * @return {{$async: boolean, $validator: asyncValidator, $watchTargets: watchTargets}} 18861 */ 18862 18863function withAsync($validator) { 18864 let $watchTargets = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 18865 const validatorObj = normalizeValidatorObject($validator); 18866 return Object.assign({}, validatorObj, { 18867 $async: true, 18868 $watchTargets 18869 }); 18870} 18871 18872function forEach(validators) { 18873 return { 18874 $validator(collection) { 18875 for (var _len = arguments.length, others = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 18876 others[_key - 1] = arguments[_key]; 18877 } 18878 18879 // go over the collection. It can be a ref as well. 18880 return (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(collection).reduce((previous, collectionItem, index) => { 18881 // go over each property 18882 const collectionEntryResult = Object.entries(collectionItem).reduce((all, _ref) => { 18883 let [property, $model] = _ref; 18884 // get the validators for this property 18885 const innerValidators = validators[property] || {}; // go over each validator and run it 18886 18887 const propertyResult = Object.entries(innerValidators).reduce((all, _ref2) => { 18888 let [validatorName, currentValidator] = _ref2; 18889 // extract the validator. Supports simple and extended validators. 18890 const validatorFunction = unwrapNormalizedValidator(currentValidator); // Call the validator, passing the VM as this, the value, current iterated object and the rest. 18891 18892 const $response = validatorFunction.call(this, $model, collectionItem, index, ...others); // extract the valid from the result 18893 18894 const $valid = unwrapValidatorResponse($response); // store the entire response for later 18895 18896 all.$data[validatorName] = $response; 18897 all.$data.$invalid = !$valid || !!all.$data.$invalid; 18898 all.$data.$error = all.$data.$invalid; // if not valid, get the $message 18899 18900 if (!$valid) { 18901 let $message = currentValidator.$message || ''; 18902 const $params = currentValidator.$params || {}; // If $message is a function, we call it with the appropriate parameters 18903 18904 if (typeof $message === 'function') { 18905 $message = $message({ 18906 $pending: false, 18907 $invalid: !$valid, 18908 $params, 18909 $model, 18910 $response 18911 }); 18912 } // save the error object 18913 18914 18915 all.$errors.push({ 18916 $property: property, 18917 $message, 18918 $params, 18919 $response, 18920 $model, 18921 $pending: false, 18922 $validator: validatorName 18923 }); 18924 } 18925 18926 return { 18927 $valid: all.$valid && $valid, 18928 $data: all.$data, 18929 $errors: all.$errors 18930 }; 18931 }, { 18932 $valid: true, 18933 $data: {}, 18934 $errors: [] 18935 }); 18936 all.$data[property] = propertyResult.$data; 18937 all.$errors[property] = propertyResult.$errors; 18938 return { 18939 $valid: all.$valid && propertyResult.$valid, 18940 $data: all.$data, 18941 $errors: all.$errors 18942 }; 18943 }, { 18944 $valid: true, 18945 $data: {}, 18946 $errors: {} 18947 }); 18948 return { 18949 $valid: previous.$valid && collectionEntryResult.$valid, 18950 $data: previous.$data.concat(collectionEntryResult.$data), 18951 $errors: previous.$errors.concat(collectionEntryResult.$errors) 18952 }; 18953 }, { 18954 $valid: true, 18955 $data: [], 18956 $errors: [] 18957 }); 18958 }, 18959 18960 // collect all the validation errors into a 2 dimensional array, for each entry in the collection, you have an array of error messages. 18961 $message: _ref3 => { 18962 let { 18963 $response 18964 } = _ref3; 18965 return $response ? $response.$errors.map(context => { 18966 return Object.values(context).map(errors => errors.map(error => error.$message)).reduce((a, b) => a.concat(b), []); 18967 }) : []; 18968 } 18969 }; 18970} 18971 18972// "required" core, used in almost every validator to allow empty values 18973const req = value => { 18974 value = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(value); 18975 if (Array.isArray(value)) return !!value.length; 18976 18977 if (value === undefined || value === null) { 18978 return false; 18979 } 18980 18981 if (value === false) { 18982 return true; 18983 } 18984 18985 if (value instanceof Date) { 18986 // invalid date won't pass 18987 return !isNaN(value.getTime()); 18988 } 18989 18990 if (typeof value === 'object') { 18991 for (let _ in value) return true; 18992 18993 return false; 18994 } 18995 18996 return !!String(value).length; 18997}; 18998/** 18999 * Returns the length of an arbitrary value 19000 * @param {Array|Object|String} value 19001 * @return {number} 19002 */ 19003 19004const len = value => { 19005 value = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(value); 19006 if (Array.isArray(value)) return value.length; 19007 19008 if (typeof value === 'object') { 19009 return Object.keys(value).length; 19010 } 19011 19012 return String(value).length; 19013}; 19014/** 19015 * Regex based validator template 19016 * @param {RegExp} expr 19017 * @return {function(*=): boolean} 19018 */ 19019 19020function regex() { 19021 for (var _len = arguments.length, expr = new Array(_len), _key = 0; _key < _len; _key++) { 19022 expr[_key] = arguments[_key]; 19023 } 19024 19025 return value => { 19026 value = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(value); 19027 return !req(value) || expr.every(reg => reg.test(value)); 19028 }; 19029} 19030 19031var common = /*#__PURE__*/Object.freeze({ 19032 __proto__: null, 19033 withParams: withParams, 19034 withMessage: withMessage, 19035 withAsync: withAsync, 19036 forEach: forEach, 19037 req: req, 19038 len: len, 19039 regex: regex, 19040 unwrap: vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref, 19041 unwrapNormalizedValidator: unwrapNormalizedValidator, 19042 unwrapValidatorResponse: unwrapValidatorResponse, 19043 normalizeValidatorObject: normalizeValidatorObject 19044}); 19045 19046var alpha$1 = regex(/^[a-zA-Z]*$/); 19047 19048/** 19049 * Validate if value is alphabetical string. 19050 * @type {NormalizedValidator} 19051 */ 19052 19053var alpha = { 19054 $validator: alpha$1, 19055 $message: 'The value is not alphabetical', 19056 $params: { 19057 type: 'alpha' 19058 } 19059}; 19060 19061var alphaNum$1 = regex(/^[a-zA-Z0-9]*$/); 19062 19063/** 19064 * Validate if value is alpha-numeric string. 19065 * @type {NormalizedValidator} 19066 */ 19067 19068var alphaNum = { 19069 $validator: alphaNum$1, 19070 $message: 'The value must be alpha-numeric', 19071 $params: { 19072 type: 'alphaNum' 19073 } 19074}; 19075 19076var numeric$1 = regex(/^\d*(\.\d+)?$/); 19077 19078/** 19079 * Check whether a value is numeric. 19080 * @type NormalizedValidator 19081 */ 19082 19083var numeric = { 19084 $validator: numeric$1, 19085 $message: 'Value must be numeric', 19086 $params: { 19087 type: 'numeric' 19088 } 19089}; 19090 19091/** 19092 * Check if a numeric value is between two values. 19093 * @param {Ref<Number> | Number} min 19094 * @param {Ref<Number> | Number} max 19095 * @return {function(*=): boolean} 19096 */ 19097 19098function between$1 (min, max) { 19099 return value => !req(value) || (!/\s/.test(value) || value instanceof Date) && +(0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(min) <= +value && +(0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(max) >= +value; 19100} 19101 19102/** 19103 * Checks if a value is between two values. 19104 * @param {Ref<Number> | Number} min 19105 * @param {Ref<Number> | Number} max 19106 * @return {NormalizedValidator} 19107 */ 19108 19109function between (min, max) { 19110 return { 19111 $validator: between$1(min, max), 19112 $message: _ref => { 19113 let { 19114 $params 19115 } = _ref; 19116 return `The value must be between ${$params.min} and ${$params.max}`; 19117 }, 19118 $params: { 19119 min, 19120 max, 19121 type: 'between' 19122 } 19123 }; 19124} 19125 19126const emailRegex = /^(?:[A-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9]{2,}(?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i; 19127var email$1 = regex(emailRegex); 19128 19129/** 19130 * Validate if value is an email. 19131 * @type {NormalizedValidator} 19132 */ 19133 19134var email = { 19135 $validator: email$1, 19136 $message: 'Value is not a valid email address', 19137 $params: { 19138 type: 'email' 19139 } 19140}; 19141 19142/** 19143 * Check if a string is an IP Address 19144 * @param {String} value 19145 * @returns {boolean} 19146 */ 19147 19148function ipAddress$1 (value) { 19149 if (!req(value)) { 19150 return true; 19151 } 19152 19153 if (typeof value !== 'string') { 19154 return false; 19155 } 19156 19157 const nibbles = value.split('.'); 19158 return nibbles.length === 4 && nibbles.every(nibbleValid); 19159} 19160 19161const nibbleValid = nibble => { 19162 if (nibble.length > 3 || nibble.length === 0) { 19163 return false; 19164 } 19165 19166 if (nibble[0] === '0' && nibble !== '0') { 19167 return false; 19168 } 19169 19170 if (!nibble.match(/^\d+$/)) { 19171 return false; 19172 } 19173 19174 const numeric = +nibble | 0; 19175 return numeric >= 0 && numeric <= 255; 19176}; 19177 19178/** 19179 * Validate if value is an ipAddress string. 19180 * @type {NormalizedValidator} 19181 */ 19182 19183var ipAddress = { 19184 $validator: ipAddress$1, 19185 $message: 'The value is not a valid IP address', 19186 $params: { 19187 type: 'ipAddress' 19188 } 19189}; 19190 19191/** 19192 * Check if value is a properly formatted Mac Address. 19193 * @param {String | Ref<String>} [separator] 19194 * @returns {function(*): boolean} 19195 */ 19196 19197function macAddress$1 () { 19198 let separator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ':'; 19199 return value => { 19200 separator = (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(separator); 19201 19202 if (!req(value)) { 19203 return true; 19204 } 19205 19206 if (typeof value !== 'string') { 19207 return false; 19208 } 19209 19210 const parts = typeof separator === 'string' && separator !== '' ? value.split(separator) : value.length === 12 || value.length === 16 ? value.match(/.{2}/g) : null; 19211 return parts !== null && (parts.length === 6 || parts.length === 8) && parts.every(hexValid); 19212 }; 19213} 19214 19215const hexValid = hex => hex.toLowerCase().match(/^[0-9a-f]{2}$/); 19216 19217/** 19218 * Validate if value is a valid Mac Address string. 19219 * @returns {NormalizedValidator} 19220 */ 19221 19222function macAddress (separator) { 19223 return { 19224 $validator: macAddress$1(separator), 19225 $message: 'The value is not a valid MAC Address', 19226 $params: { 19227 type: 'macAddress' 19228 } 19229 }; 19230} 19231 19232/** 19233 * Check if provided value has a maximum length 19234 * @param {Number | Ref<Number>} length 19235 * @returns {function(Array|Object|String): boolean} 19236 */ 19237 19238function maxLength$1 (length) { 19239 return value => !req(value) || len(value) <= (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(length); 19240} 19241 19242/** 19243 * Validate the max length of a string. 19244 * @param {Number} max 19245 * @return {NormalizedValidator} 19246 */ 19247 19248function maxLength (max) { 19249 return { 19250 $validator: maxLength$1(max), 19251 $message: _ref => { 19252 let { 19253 $params 19254 } = _ref; 19255 return `The maximum length allowed is ${$params.max}`; 19256 }, 19257 $params: { 19258 max, 19259 type: 'maxLength' 19260 } 19261 }; 19262} 19263 19264/** 19265 * Check if value is above a threshold. 19266 * @param {Number | Ref<Number>} length 19267 * @returns {function(Array|Object|String): boolean} 19268 */ 19269 19270function minLength$1 (length) { 19271 return value => !req(value) || len(value) >= (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(length); 19272} 19273 19274/** 19275 * Check if value is above a threshold. 19276 * @param {Number | Ref<Number>} min 19277 * @returns {NormalizedValidator} 19278 */ 19279 19280function minLength (min) { 19281 return { 19282 $validator: minLength$1(min), 19283 $message: _ref => { 19284 let { 19285 $params 19286 } = _ref; 19287 return `This field should be at least ${$params.min} characters long`; 19288 }, 19289 $params: { 19290 min, 19291 type: 'minLength' 19292 } 19293 }; 19294} 19295 19296/** 19297 * Validates if a value is empty. 19298 * @param {String | Array | Date | Object} value 19299 * @returns {boolean} 19300 */ 19301 19302function required$1 (value) { 19303 if (typeof value === 'string') { 19304 value = value.trim(); 19305 } 19306 19307 return req(value); 19308} 19309 19310/** 19311 * Check if a value is empty or not. 19312 * @type {NormalizedValidator} 19313 */ 19314 19315var required = { 19316 $validator: required$1, 19317 $message: 'Value is required', 19318 $params: { 19319 type: 'required' 19320 } 19321}; 19322 19323const validate$1 = (prop, val) => prop ? req(typeof val === 'string' ? val.trim() : val) : true; 19324/** 19325 * Returns required if the passed property is truthy 19326 * @param {Boolean | String | function(any): Boolean | Ref<string | boolean>} propOrFunction 19327 * @return {function(value: *, parentVM: object): Boolean} 19328 */ 19329 19330 19331function requiredIf$1(propOrFunction) { 19332 return function (value, parentVM) { 19333 if (typeof propOrFunction !== 'function') { 19334 return validate$1((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(propOrFunction), value); 19335 } 19336 19337 const result = propOrFunction.call(this, value, parentVM); 19338 return validate$1(result, value); 19339 }; 19340} 19341 19342/** 19343 * Returns required if the passed property is truthy 19344 * @param {Boolean | String | function(): (Boolean | Promise<boolean>)} prop 19345 * @return {NormalizedValidator} 19346 */ 19347 19348function requiredIf (prop) { 19349 return { 19350 $validator: requiredIf$1(prop), 19351 $message: 'The value is required', 19352 $params: { 19353 type: 'requiredIf', 19354 prop 19355 } 19356 }; 19357} 19358 19359const validate = (prop, val) => !prop ? req(typeof val === 'string' ? val.trim() : val) : true; 19360/** 19361 * Returns required if the passed property is falsy. 19362 * @param {Boolean | String | function(any): Boolean | Ref<string | boolean>} propOrFunction 19363 * @return {function(value: *, parentVM: object): Boolean} 19364 */ 19365 19366 19367function requiredUnless$1(propOrFunction) { 19368 return function (value, parentVM) { 19369 if (typeof propOrFunction !== 'function') { 19370 return validate((0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(propOrFunction), value); 19371 } 19372 19373 const result = propOrFunction.call(this, value, parentVM); 19374 return validate(result, value); 19375 }; 19376} 19377 19378/** 19379 * Returns required unless the passed property is truthy 19380 * @param {Boolean | String | function(): (Boolean | Promise<boolean>)} prop 19381 * @return {NormalizedValidator} 19382 */ 19383 19384function requiredUnless (prop) { 19385 return { 19386 $validator: requiredUnless$1(prop), 19387 $message: 'The value is required', 19388 $params: { 19389 type: 'requiredUnless', 19390 prop 19391 } 19392 }; 19393} 19394 19395/** 19396 * Check if two values are identical. 19397 * @param {*} equalTo 19398 * @return {function(*=): boolean} 19399 */ 19400 19401function sameAs$1 (equalTo) { 19402 return value => (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(value) === (0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(equalTo); 19403} 19404 19405/** 19406 * Check if two values are identical 19407 * @param {*} equalTo 19408 * @param {String} [otherName] 19409 * @return {NormalizedValidator} 19410 */ 19411 19412function sameAs (equalTo) { 19413 let otherName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'other'; 19414 return { 19415 $validator: sameAs$1(equalTo), 19416 $message: _ref => { 19417 return `The value must be equal to the ${otherName} value`; 19418 }, 19419 $params: { 19420 equalTo, 19421 otherName, 19422 type: 'sameAs' 19423 } 19424 }; 19425} 19426 19427/** 19428 * Regex taken from {@link https://gist.github.com/dperini/729294} 19429 */ 19430 19431const urlRegex = /^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/i; 19432var url$1 = regex(urlRegex); 19433 19434/** 19435 * Check if a value is a url 19436 * @type {NormalizedValidator} 19437 */ 19438 19439var url = { 19440 $validator: url$1, 19441 $message: 'The value is not a valid URL address', 19442 $params: { 19443 type: 'url' 19444 } 19445}; 19446 19447function _await$1(value, then, direct) { 19448 if (direct) { 19449 return then ? then(value) : value; 19450 } 19451 19452 if (!value || !value.then) { 19453 value = Promise.resolve(value); 19454 } 19455 19456 return then ? value.then(then) : value; 19457} 19458 19459function syncOr(validators) { 19460 return function () { 19461 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 19462 args[_key] = arguments[_key]; 19463 } 19464 19465 return validators.reduce((valid, fn) => { 19466 if (unwrapValidatorResponse(valid)) return valid; 19467 return unwrapNormalizedValidator(fn).apply(this, args); 19468 }, false); 19469 }; 19470} 19471 19472function asyncOr(validators) { 19473 return function () { 19474 const _this = this; 19475 19476 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 19477 args[_key2] = arguments[_key2]; 19478 } 19479 19480 return validators.reduce(function (valid, fn) { 19481 return _await$1(valid, function (r) { 19482 return unwrapValidatorResponse(r) ? r : unwrapNormalizedValidator(fn).apply(_this, args); 19483 }); 19484 }, Promise.resolve(false)); 19485 }; 19486} 19487/** 19488 * Returns true when one of the provided functions returns true. 19489 * @param {...(NormalizedValidator|Function)} validators 19490 * @return {{$validator: function(...[*]=): (boolean | Promise<boolean>), $async: boolean, $watchTargets: any[]}} 19491 */ 19492 19493 19494function or$1() { 19495 for (var _len3 = arguments.length, validators = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { 19496 validators[_key3] = arguments[_key3]; 19497 } 19498 19499 const $async = validators.some(v => v.$async); 19500 const $watchTargets = validators.reduce((all, v) => { 19501 if (!v.$watchTargets) return all; 19502 return all.concat(v.$watchTargets); 19503 }, []); 19504 19505 let $validator = () => false; 19506 19507 if (validators.length) $validator = $async ? asyncOr(validators) : syncOr(validators); 19508 return { 19509 $async, 19510 $validator, 19511 $watchTargets 19512 }; 19513} 19514 19515/** 19516 * Returns true when one of the provided functions returns true. 19517 * @param {...(NormalizedValidator|Function)} validators 19518 * @return {NormalizedValidator} 19519 */ 19520 19521function or () { 19522 return withParams({ 19523 type: 'or' 19524 }, withMessage('The value does not match any of the provided validators', or$1(...arguments))); 19525} 19526 19527function _await(value, then, direct) { 19528 if (direct) { 19529 return then ? then(value) : value; 19530 } 19531 19532 if (!value || !value.then) { 19533 value = Promise.resolve(value); 19534 } 19535 19536 return then ? value.then(then) : value; 19537} 19538/** 19539 * 19540 * @param validators 19541 * @return {function(...[*]=): Promise<boolean>} 19542 */ 19543 19544 19545function syncAnd(validators) { 19546 return function () { 19547 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 19548 args[_key] = arguments[_key]; 19549 } 19550 19551 return validators.reduce((valid, fn) => { 19552 if (!unwrapValidatorResponse(valid)) return valid; 19553 return unwrapNormalizedValidator(fn).apply(this, args); 19554 }, true); 19555 }; 19556} 19557 19558function asyncAnd(validators) { 19559 return function () { 19560 const _this = this; 19561 19562 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 19563 args[_key2] = arguments[_key2]; 19564 } 19565 19566 return validators.reduce(function (valid, fn) { 19567 return _await(valid, function (r) { 19568 return unwrapValidatorResponse(r) ? unwrapNormalizedValidator(fn).apply(_this, args) : r; 19569 }); 19570 }, Promise.resolve(true)); 19571 }; 19572} 19573/** 19574 * Returns true when all validators are truthy 19575 * @param {...(NormalizedValidator | Function)} validators 19576 * @return {{$validator: function(...[*]=): (boolean | Promise<boolean>), $async: boolean, $watchTargets: any[]}} 19577 */ 19578 19579 19580function and$1() { 19581 for (var _len3 = arguments.length, validators = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { 19582 validators[_key3] = arguments[_key3]; 19583 } 19584 19585 const $async = validators.some(v => v.$async); 19586 const $watchTargets = validators.reduce((all, v) => { 19587 if (!v.$watchTargets) return all; 19588 return all.concat(v.$watchTargets); 19589 }, []); 19590 19591 let $validator = () => false; 19592 19593 if (validators.length) $validator = $async ? asyncAnd(validators) : syncAnd(validators); 19594 return { 19595 $async, 19596 $validator, 19597 $watchTargets 19598 }; 19599} 19600 19601/** 19602 * Validate if all validators match. 19603 * @param {...*} validators 19604 * @returns {NormalizedValidator} 19605 */ 19606 19607function and () { 19608 return withParams({ 19609 type: 'and' 19610 }, withMessage('The value does not match all of the provided validators', and$1(...arguments))); 19611} 19612 19613/** 19614 * Swaps the result of a value 19615 * @param {NormalizedValidator|Function} validator 19616 * @returns {function(*=, *=): boolean} 19617 */ 19618 19619function not$1 (validator) { 19620 return function (value, vm) { 19621 if (!req(value)) return true; 19622 const response = unwrapNormalizedValidator(validator).call(this, value, vm); 19623 if (!isPromise(response)) return !unwrapValidatorResponse(response); 19624 return response.then(r => !unwrapValidatorResponse(r)); 19625 }; 19626} 19627 19628/** 19629 * Swaps the result of a value 19630 * @param {NormalizedValidator|Function} validator 19631 * @returns {NormalizedValidator} 19632 */ 19633 19634function not (validator) { 19635 return { 19636 $validator: not$1(validator), 19637 $message: `The value does not match the provided validator`, 19638 $params: { 19639 type: 'not' 19640 } 19641 }; 19642} 19643 19644/** 19645 * Check if a value is above a threshold. 19646 * @param {String | Number | Ref<Number> | Ref<String>} min 19647 * @returns {function(*=): boolean} 19648 */ 19649 19650function minValue$1 (min) { 19651 return value => !req(value) || (!/\s/.test(value) || value instanceof Date) && +value >= +(0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(min); 19652} 19653 19654/** 19655 * Check if a value is above a threshold. 19656 * @param {String | Number | Ref<Number> | Ref<String>} min 19657 * @returns {NormalizedValidator} 19658 */ 19659 19660function minValue (min) { 19661 return { 19662 $validator: minValue$1(min), 19663 $message: _ref => { 19664 let { 19665 $params 19666 } = _ref; 19667 return `The minimum value allowed is ${$params.min}`; 19668 }, 19669 $params: { 19670 min, 19671 type: 'minValue' 19672 } 19673 }; 19674} 19675 19676/** 19677 * Check if value is below a threshold. 19678 * @param {Number | Ref<Number> | Ref<String>} max 19679 * @returns {function(*=): boolean} 19680 */ 19681 19682function maxValue$1 (max) { 19683 return value => !req(value) || (!/\s/.test(value) || value instanceof Date) && +value <= +(0,vue_demi__WEBPACK_IMPORTED_MODULE_0__.unref)(max); 19684} 19685 19686/** 19687 * Check if value is below a threshold. 19688 * @param {Number | Ref<Number> | Ref<String>} max 19689 * @return {NormalizedValidator} 19690 */ 19691 19692var maxValue = (max => ({ 19693 $validator: maxValue$1(max), 19694 $message: _ref => { 19695 let { 19696 $params 19697 } = _ref; 19698 return `The maximum value allowed is ${$params.max}`; 19699 }, 19700 $params: { 19701 max, 19702 type: 'maxValue' 19703 } 19704})); 19705 19706// ^-[0-9]+$ - only for negative integer (minus sign without at least 1 digit is not a number) 19707 19708var integer$1 = regex(/(^[0-9]*$)|(^-[0-9]+$)/); 19709 19710/** 19711 * Validate if value is integer. 19712 * @type {NormalizedValidator} 19713 */ 19714 19715var integer = { 19716 $validator: integer$1, 19717 $message: 'Value is not an integer', 19718 $params: { 19719 type: 'integer' 19720 } 19721}; 19722 19723var decimal$1 = regex(/^[-]?\d*(\.\d+)?$/); 19724 19725/** 19726 * Validate if value is decimal number. 19727 * @type {NormalizedValidator} 19728 */ 19729 19730var decimal = { 19731 $validator: decimal$1, 19732 $message: 'Value must be decimal', 19733 $params: { 19734 type: 'decimal' 19735 } 19736}; 19737 19738/** 19739 * Creates a translatable version of `withMessage` helper. 19740 * @param {function} t - the translation function of your choice 19741 * @param {function} [messagePath] - a function to generate the message path, passed to `t` for each message. By default it is `validations.${$validator}` 19742 * @param {function} [messageParams] - a function to augment the params, passed to `t` for each message. 19743 */ 19744 19745function createI18nMessage(_ref) { 19746 let { 19747 t, 19748 messagePath = _ref2 => { 19749 let { 19750 $validator 19751 } = _ref2; 19752 return `validations.${$validator}`; 19753 }, 19754 messageParams = params => params 19755 } = _ref; 19756 return function withI18nMessage(validator) { 19757 let { 19758 withArguments = false, 19759 messagePath: localMessagePath = messagePath, 19760 messageParams: localMessageParams = messageParams 19761 } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 19762 19763 function message(props) { 19764 return t(localMessagePath(props), localMessageParams(Object.assign({ 19765 model: props.$model, 19766 property: props.$property, 19767 pending: props.$pending, 19768 invalid: props.$invalid, 19769 response: props.$response, 19770 validator: props.$validator, 19771 propertyPath: props.$propertyPath 19772 }, props.$params))); 19773 } 19774 19775 if (withArguments && typeof validator === 'function') { 19776 return function () { 19777 return withMessage(message, validator(...arguments)); 19778 }; 19779 } 19780 19781 return withMessage(message, validator); 19782 }; 19783} 19784 19785 19786 19787 19788/***/ }), 19789
vendor: 347 bytes, lines 19790-19799
19790/***/ "./node_modules/axios/index.js": 19791/*!*************************************!*\ 19792 !*** ./node_modules/axios/index.js ***! 19793 \*************************************/ 19794/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 19795 19796module.exports = __webpack_require__(/*! ./lib/axios */ "./node_modules/axios/lib/axios.js"); 19797 19798/***/ }), 19799
vendor: 8,403 bytes, lines 19800-20032
19800/***/ "./node_modules/axios/lib/adapters/xhr.js": 19801/*!************************************************!*\ 19802 !*** ./node_modules/axios/lib/adapters/xhr.js ***! 19803 \************************************************/ 19804/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 19805 19806"use strict"; 19807 19808 19809var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 19810var settle = __webpack_require__(/*! ./../core/settle */ "./node_modules/axios/lib/core/settle.js"); 19811var cookies = __webpack_require__(/*! ./../helpers/cookies */ "./node_modules/axios/lib/helpers/cookies.js"); 19812var buildURL = __webpack_require__(/*! ./../helpers/buildURL */ "./node_modules/axios/lib/helpers/buildURL.js"); 19813var buildFullPath = __webpack_require__(/*! ../core/buildFullPath */ "./node_modules/axios/lib/core/buildFullPath.js"); 19814var parseHeaders = __webpack_require__(/*! ./../helpers/parseHeaders */ "./node_modules/axios/lib/helpers/parseHeaders.js"); 19815var isURLSameOrigin = __webpack_require__(/*! ./../helpers/isURLSameOrigin */ "./node_modules/axios/lib/helpers/isURLSameOrigin.js"); 19816var transitionalDefaults = __webpack_require__(/*! ../defaults/transitional */ "./node_modules/axios/lib/defaults/transitional.js"); 19817var AxiosError = __webpack_require__(/*! ../core/AxiosError */ "./node_modules/axios/lib/core/AxiosError.js"); 19818var CanceledError = __webpack_require__(/*! ../cancel/CanceledError */ "./node_modules/axios/lib/cancel/CanceledError.js"); 19819var parseProtocol = __webpack_require__(/*! ../helpers/parseProtocol */ "./node_modules/axios/lib/helpers/parseProtocol.js"); 19820 19821module.exports = function xhrAdapter(config) { 19822 return new Promise(function dispatchXhrRequest(resolve, reject) { 19823 var requestData = config.data; 19824 var requestHeaders = config.headers; 19825 var responseType = config.responseType; 19826 var onCanceled; 19827 function done() { 19828 if (config.cancelToken) { 19829 config.cancelToken.unsubscribe(onCanceled); 19830 } 19831 19832 if (config.signal) { 19833 config.signal.removeEventListener('abort', onCanceled); 19834 } 19835 } 19836 19837 if (utils.isFormData(requestData) && utils.isStandardBrowserEnv()) { 19838 delete requestHeaders['Content-Type']; // Let the browser set it 19839 } 19840 19841 var request = new XMLHttpRequest(); 19842 19843 // HTTP basic authentication 19844 if (config.auth) { 19845 var username = config.auth.username || ''; 19846 var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : ''; 19847 requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password); 19848 } 19849 19850 var fullPath = buildFullPath(config.baseURL, config.url); 19851 19852 request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true); 19853 19854 // Set the request timeout in MS 19855 request.timeout = config.timeout; 19856 19857 function onloadend() { 19858 if (!request) { 19859 return; 19860 } 19861 // Prepare the response 19862 var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null; 19863 var responseData = !responseType || responseType === 'text' || responseType === 'json' ? 19864 request.responseText : request.response; 19865 var response = { 19866 data: responseData, 19867 status: request.status, 19868 statusText: request.statusText, 19869 headers: responseHeaders, 19870 config: config, 19871 request: request 19872 }; 19873 19874 settle(function _resolve(value) { 19875 resolve(value); 19876 done(); 19877 }, function _reject(err) { 19878 reject(err); 19879 done(); 19880 }, response); 19881 19882 // Clean up request 19883 request = null; 19884 } 19885 19886 if ('onloadend' in request) { 19887 // Use onloadend if available 19888 request.onloadend = onloadend; 19889 } else { 19890 // Listen for ready state to emulate onloadend 19891 request.onreadystatechange = function handleLoad() { 19892 if (!request || request.readyState !== 4) { 19893 return; 19894 } 19895 19896 // The request errored out and we didn't get a response, this will be 19897 // handled by onerror instead 19898 // With one exception: request that using file: protocol, most browsers 19899 // will return status as 0 even though it's a successful request 19900 if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) { 19901 return; 19902 } 19903 // readystate handler is calling before onerror or ontimeout handlers, 19904 // so we should call onloadend on the next 'tick' 19905 setTimeout(onloadend); 19906 }; 19907 } 19908 19909 // Handle browser request cancellation (as opposed to a manual cancellation) 19910 request.onabort = function handleAbort() { 19911 if (!request) { 19912 return; 19913 } 19914 19915 reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request)); 19916 19917 // Clean up request 19918 request = null; 19919 }; 19920 19921 // Handle low level network errors 19922 request.onerror = function handleError() { 19923 // Real errors are hidden from us by the browser 19924 // onerror should only fire if it's a network error 19925 reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request, request)); 19926 19927 // Clean up request 19928 request = null; 19929 }; 19930 19931 // Handle timeout 19932 request.ontimeout = function handleTimeout() { 19933 var timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded'; 19934 var transitional = config.transitional || transitionalDefaults; 19935 if (config.timeoutErrorMessage) { 19936 timeoutErrorMessage = config.timeoutErrorMessage; 19937 } 19938 reject(new AxiosError( 19939 timeoutErrorMessage, 19940 transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED, 19941 config, 19942 request)); 19943 19944 // Clean up request 19945 request = null; 19946 }; 19947 19948 // Add xsrf header 19949 // This is only done if running in a standard browser environment. 19950 // Specifically not if we're in a web worker, or react-native. 19951 if (utils.isStandardBrowserEnv()) { 19952 // Add xsrf header 19953 var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? 19954 cookies.read(config.xsrfCookieName) : 19955 undefined; 19956 19957 if (xsrfValue) { 19958 requestHeaders[config.xsrfHeaderName] = xsrfValue; 19959 } 19960 } 19961 19962 // Add headers to the request 19963 if ('setRequestHeader' in request) { 19964 utils.forEach(requestHeaders, function setRequestHeader(val, key) { 19965 if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') { 19966 // Remove Content-Type if data is undefined 19967 delete requestHeaders[key]; 19968 } else { 19969 // Otherwise add header to the request 19970 request.setRequestHeader(key, val); 19971 } 19972 }); 19973 } 19974 19975 // Add withCredentials to request if needed 19976 if (!utils.isUndefined(config.withCredentials)) { 19977 request.withCredentials = !!config.withCredentials; 19978 } 19979 19980 // Add responseType to request if needed 19981 if (responseType && responseType !== 'json') { 19982 request.responseType = config.responseType; 19983 } 19984 19985 // Handle progress if needed 19986 if (typeof config.onDownloadProgress === 'function') { 19987 request.addEventListener('progress', config.onDownloadProgress); 19988 } 19989 19990 // Not all browsers support upload events 19991 if (typeof config.onUploadProgress === 'function' && request.upload) { 19992 request.upload.addEventListener('progress', config.onUploadProgress); 19993 } 19994 19995 if (config.cancelToken || config.signal) { 19996 // Handle cancellation 19997 // eslint-disable-next-line func-names 19998 onCanceled = function(cancel) { 19999 if (!request) { 20000 return; 20001 } 20002 reject(!cancel || (cancel && cancel.type) ? new CanceledError() : cancel); 20003 request.abort(); 20004 request = null; 20005 }; 20006 20007 config.cancelToken && config.cancelToken.subscribe(onCanceled); 20008 if (config.signal) { 20009 config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled); 20010 } 20011 } 20012 20013 if (!requestData) { 20014 requestData = null; 20015 } 20016 20017 var protocol = parseProtocol(fullPath); 20018 20019 if (protocol && [ 'http', 'https', 'file' ].indexOf(protocol) === -1) { 20020 reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config)); 20021 return; 20022 } 20023 20024 20025 // Send the request 20026 request.send(requestData); 20027 }); 20028}; 20029 20030 20031/***/ }), 20032
vendor: 2,884 bytes, lines 20033-20107
20033/***/ "./node_modules/axios/lib/axios.js": 20034/*!*****************************************!*\ 20035 !*** ./node_modules/axios/lib/axios.js ***! 20036 \*****************************************/ 20037/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20038 20039"use strict"; 20040 20041 20042var utils = __webpack_require__(/*! ./utils */ "./node_modules/axios/lib/utils.js"); 20043var bind = __webpack_require__(/*! ./helpers/bind */ "./node_modules/axios/lib/helpers/bind.js"); 20044var Axios = __webpack_require__(/*! ./core/Axios */ "./node_modules/axios/lib/core/Axios.js"); 20045var mergeConfig = __webpack_require__(/*! ./core/mergeConfig */ "./node_modules/axios/lib/core/mergeConfig.js"); 20046var defaults = __webpack_require__(/*! ./defaults */ "./node_modules/axios/lib/defaults/index.js"); 20047 20048/** 20049 * Create an instance of Axios 20050 * 20051 * @param {Object} defaultConfig The default config for the instance 20052 * @return {Axios} A new instance of Axios 20053 */ 20054function createInstance(defaultConfig) { 20055 var context = new Axios(defaultConfig); 20056 var instance = bind(Axios.prototype.request, context); 20057 20058 // Copy axios.prototype to instance 20059 utils.extend(instance, Axios.prototype, context); 20060 20061 // Copy context to instance 20062 utils.extend(instance, context); 20063 20064 // Factory for creating new instances 20065 instance.create = function create(instanceConfig) { 20066 return createInstance(mergeConfig(defaultConfig, instanceConfig)); 20067 }; 20068 20069 return instance; 20070} 20071 20072// Create the default instance to be exported 20073var axios = createInstance(defaults); 20074 20075// Expose Axios class to allow class inheritance 20076axios.Axios = Axios; 20077 20078// Expose Cancel & CancelToken 20079axios.CanceledError = __webpack_require__(/*! ./cancel/CanceledError */ "./node_modules/axios/lib/cancel/CanceledError.js"); 20080axios.CancelToken = __webpack_require__(/*! ./cancel/CancelToken */ "./node_modules/axios/lib/cancel/CancelToken.js"); 20081axios.isCancel = __webpack_require__(/*! ./cancel/isCancel */ "./node_modules/axios/lib/cancel/isCancel.js"); 20082axios.VERSION = (__webpack_require__(/*! ./env/data */ "./node_modules/axios/lib/env/data.js").version); 20083axios.toFormData = __webpack_require__(/*! ./helpers/toFormData */ "./node_modules/axios/lib/helpers/toFormData.js"); 20084 20085// Expose AxiosError class 20086axios.AxiosError = __webpack_require__(/*! ../lib/core/AxiosError */ "./node_modules/axios/lib/core/AxiosError.js"); 20087 20088// alias for CanceledError for backward compatibility 20089axios.Cancel = axios.CanceledError; 20090 20091// Expose all/spread 20092axios.all = function all(promises) { 20093 return Promise.all(promises); 20094}; 20095axios.spread = __webpack_require__(/*! ./helpers/spread */ "./node_modules/axios/lib/helpers/spread.js"); 20096 20097// Expose isAxiosError 20098axios.isAxiosError = __webpack_require__(/*! ./helpers/isAxiosError */ "./node_modules/axios/lib/helpers/isAxiosError.js"); 20099 20100module.exports = axios; 20101 20102// Allow use of default import syntax in TypeScript 20103module.exports["default"] = axios; 20104 20105 20106/***/ }), 20107
vendor: 2,888 bytes, lines 20108-20237
20108/***/ "./node_modules/axios/lib/cancel/CancelToken.js": 20109/*!******************************************************!*\ 20110 !*** ./node_modules/axios/lib/cancel/CancelToken.js ***! 20111 \******************************************************/ 20112/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20113 20114"use strict"; 20115 20116 20117var CanceledError = __webpack_require__(/*! ./CanceledError */ "./node_modules/axios/lib/cancel/CanceledError.js"); 20118 20119/** 20120 * A `CancelToken` is an object that can be used to request cancellation of an operation. 20121 * 20122 * @class 20123 * @param {Function} executor The executor function. 20124 */ 20125function CancelToken(executor) { 20126 if (typeof executor !== 'function') { 20127 throw new TypeError('executor must be a function.'); 20128 } 20129 20130 var resolvePromise; 20131 20132 this.promise = new Promise(function promiseExecutor(resolve) { 20133 resolvePromise = resolve; 20134 }); 20135 20136 var token = this; 20137 20138 // eslint-disable-next-line func-names 20139 this.promise.then(function(cancel) { 20140 if (!token._listeners) return; 20141 20142 var i; 20143 var l = token._listeners.length; 20144 20145 for (i = 0; i < l; i++) { 20146 token._listeners[i](cancel); 20147 } 20148 token._listeners = null; 20149 }); 20150 20151 // eslint-disable-next-line func-names 20152 this.promise.then = function(onfulfilled) { 20153 var _resolve; 20154 // eslint-disable-next-line func-names 20155 var promise = new Promise(function(resolve) { 20156 token.subscribe(resolve); 20157 _resolve = resolve; 20158 }).then(onfulfilled); 20159 20160 promise.cancel = function reject() { 20161 token.unsubscribe(_resolve); 20162 }; 20163 20164 return promise; 20165 }; 20166 20167 executor(function cancel(message) { 20168 if (token.reason) { 20169 // Cancellation has already been requested 20170 return; 20171 } 20172 20173 token.reason = new CanceledError(message); 20174 resolvePromise(token.reason); 20175 }); 20176} 20177 20178/** 20179 * Throws a `CanceledError` if cancellation has been requested. 20180 */ 20181CancelToken.prototype.throwIfRequested = function throwIfRequested() { 20182 if (this.reason) { 20183 throw this.reason; 20184 } 20185}; 20186 20187/** 20188 * Subscribe to the cancel signal 20189 */ 20190 20191CancelToken.prototype.subscribe = function subscribe(listener) { 20192 if (this.reason) { 20193 listener(this.reason); 20194 return; 20195 } 20196 20197 if (this._listeners) { 20198 this._listeners.push(listener); 20199 } else { 20200 this._listeners = [listener]; 20201 } 20202}; 20203 20204/** 20205 * Unsubscribe from the cancel signal 20206 */ 20207 20208CancelToken.prototype.unsubscribe = function unsubscribe(listener) { 20209 if (!this._listeners) { 20210 return; 20211 } 20212 var index = this._listeners.indexOf(listener); 20213 if (index !== -1) { 20214 this._listeners.splice(index, 1); 20215 } 20216}; 20217 20218/** 20219 * Returns an object that contains a new `CancelToken` and a function that, when called, 20220 * cancels the `CancelToken`. 20221 */ 20222CancelToken.source = function source() { 20223 var cancel; 20224 var token = new CancelToken(function executor(c) { 20225 cancel = c; 20226 }); 20227 return { 20228 token: token, 20229 cancel: cancel 20230 }; 20231}; 20232 20233module.exports = CancelToken; 20234 20235 20236/***/ }), 20237
vendor: 992 bytes, lines 20238-20270
20238/***/ "./node_modules/axios/lib/cancel/CanceledError.js": 20239/*!********************************************************!*\ 20240 !*** ./node_modules/axios/lib/cancel/CanceledError.js ***! 20241 \********************************************************/ 20242/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20243 20244"use strict"; 20245 20246 20247var AxiosError = __webpack_require__(/*! ../core/AxiosError */ "./node_modules/axios/lib/core/AxiosError.js"); 20248var utils = __webpack_require__(/*! ../utils */ "./node_modules/axios/lib/utils.js"); 20249 20250/** 20251 * A `CanceledError` is an object that is thrown when an operation is canceled. 20252 * 20253 * @class 20254 * @param {string=} message The message. 20255 */ 20256function CanceledError(message) { 20257 // eslint-disable-next-line no-eq-null,eqeqeq 20258 AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED); 20259 this.name = 'CanceledError'; 20260} 20261 20262utils.inherits(CanceledError, AxiosError, { 20263 __CANCEL__: true 20264}); 20265 20266module.exports = CanceledError; 20267 20268 20269/***/ }), 20270
vendor: 366 bytes, lines 20271-20286
20271/***/ "./node_modules/axios/lib/cancel/isCancel.js": 20272/*!***************************************************!*\ 20273 !*** ./node_modules/axios/lib/cancel/isCancel.js ***! 20274 \***************************************************/ 20275/***/ (function(module) { 20276 20277"use strict"; 20278 20279 20280module.exports = function isCancel(value) { 20281 return !!(value && value.__CANCEL__); 20282}; 20283 20284 20285/***/ }), 20286
vendor: 5,324 bytes, lines 20287-20457
20287/***/ "./node_modules/axios/lib/core/Axios.js": 20288/*!**********************************************!*\ 20289 !*** ./node_modules/axios/lib/core/Axios.js ***! 20290 \**********************************************/ 20291/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20292 20293"use strict"; 20294 20295 20296var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 20297var buildURL = __webpack_require__(/*! ../helpers/buildURL */ "./node_modules/axios/lib/helpers/buildURL.js"); 20298var InterceptorManager = __webpack_require__(/*! ./InterceptorManager */ "./node_modules/axios/lib/core/InterceptorManager.js"); 20299var dispatchRequest = __webpack_require__(/*! ./dispatchRequest */ "./node_modules/axios/lib/core/dispatchRequest.js"); 20300var mergeConfig = __webpack_require__(/*! ./mergeConfig */ "./node_modules/axios/lib/core/mergeConfig.js"); 20301var buildFullPath = __webpack_require__(/*! ./buildFullPath */ "./node_modules/axios/lib/core/buildFullPath.js"); 20302var validator = __webpack_require__(/*! ../helpers/validator */ "./node_modules/axios/lib/helpers/validator.js"); 20303 20304var validators = validator.validators; 20305/** 20306 * Create a new instance of Axios 20307 * 20308 * @param {Object} instanceConfig The default config for the instance 20309 */ 20310function Axios(instanceConfig) { 20311 this.defaults = instanceConfig; 20312 this.interceptors = { 20313 request: new InterceptorManager(), 20314 response: new InterceptorManager() 20315 }; 20316} 20317 20318/** 20319 * Dispatch a request 20320 * 20321 * @param {Object} config The config specific for this request (merged with this.defaults) 20322 */ 20323Axios.prototype.request = function request(configOrUrl, config) { 20324 /*eslint no-param-reassign:0*/ 20325 // Allow for axios('example/url'[, config]) a la fetch API 20326 if (typeof configOrUrl === 'string') { 20327 config = config || {}; 20328 config.url = configOrUrl; 20329 } else { 20330 config = configOrUrl || {}; 20331 } 20332 20333 config = mergeConfig(this.defaults, config); 20334 20335 // Set config.method 20336 if (config.method) { 20337 config.method = config.method.toLowerCase(); 20338 } else if (this.defaults.method) { 20339 config.method = this.defaults.method.toLowerCase(); 20340 } else { 20341 config.method = 'get'; 20342 } 20343 20344 var transitional = config.transitional; 20345 20346 if (transitional !== undefined) { 20347 validator.assertOptions(transitional, { 20348 silentJSONParsing: validators.transitional(validators.boolean), 20349 forcedJSONParsing: validators.transitional(validators.boolean), 20350 clarifyTimeoutError: validators.transitional(validators.boolean) 20351 }, false); 20352 } 20353 20354 // filter out skipped interceptors 20355 var requestInterceptorChain = []; 20356 var synchronousRequestInterceptors = true; 20357 this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { 20358 if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) { 20359 return; 20360 } 20361 20362 synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous; 20363 20364 requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected); 20365 }); 20366 20367 var responseInterceptorChain = []; 20368 this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { 20369 responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected); 20370 }); 20371 20372 var promise; 20373 20374 if (!synchronousRequestInterceptors) { 20375 var chain = [dispatchRequest, undefined]; 20376 20377 Array.prototype.unshift.apply(chain, requestInterceptorChain); 20378 chain = chain.concat(responseInterceptorChain); 20379 20380 promise = Promise.resolve(config); 20381 while (chain.length) { 20382 promise = promise.then(chain.shift(), chain.shift()); 20383 } 20384 20385 return promise; 20386 } 20387 20388 20389 var newConfig = config; 20390 while (requestInterceptorChain.length) { 20391 var onFulfilled = requestInterceptorChain.shift(); 20392 var onRejected = requestInterceptorChain.shift(); 20393 try { 20394 newConfig = onFulfilled(newConfig); 20395 } catch (error) { 20396 onRejected(error); 20397 break; 20398 } 20399 } 20400 20401 try { 20402 promise = dispatchRequest(newConfig); 20403 } catch (error) { 20404 return Promise.reject(error); 20405 } 20406 20407 while (responseInterceptorChain.length) { 20408 promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift()); 20409 } 20410 20411 return promise; 20412}; 20413 20414Axios.prototype.getUri = function getUri(config) { 20415 config = mergeConfig(this.defaults, config); 20416 var fullPath = buildFullPath(config.baseURL, config.url); 20417 return buildURL(fullPath, config.params, config.paramsSerializer); 20418}; 20419 20420// Provide aliases for supported request methods 20421utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) { 20422 /*eslint func-names:0*/ 20423 Axios.prototype[method] = function(url, config) { 20424 return this.request(mergeConfig(config || {}, { 20425 method: method, 20426 url: url, 20427 data: (config || {}).data 20428 })); 20429 }; 20430}); 20431 20432utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { 20433 /*eslint func-names:0*/ 20434 20435 function generateHTTPMethod(isForm) { 20436 return function httpMethod(url, data, config) { 20437 return this.request(mergeConfig(config || {}, { 20438 method: method, 20439 headers: isForm ? { 20440 'Content-Type': 'multipart/form-data' 20441 } : {}, 20442 url: url, 20443 data: data 20444 })); 20445 }; 20446 } 20447 20448 Axios.prototype[method] = generateHTTPMethod(); 20449 20450 Axios.prototype[method + 'Form'] = generateHTTPMethod(true); 20451}); 20452 20453module.exports = Axios; 20454 20455 20456/***/ }), 20457
vendor: 2,618 bytes, lines 20458-20554
20458/***/ "./node_modules/axios/lib/core/AxiosError.js": 20459/*!***************************************************!*\ 20460 !*** ./node_modules/axios/lib/core/AxiosError.js ***! 20461 \***************************************************/ 20462/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20463 20464"use strict"; 20465 20466 20467var utils = __webpack_require__(/*! ../utils */ "./node_modules/axios/lib/utils.js"); 20468 20469/** 20470 * Create an Error with the specified message, config, error code, request and response. 20471 * 20472 * @param {string} message The error message. 20473 * @param {string} [code] The error code (for example, 'ECONNABORTED'). 20474 * @param {Object} [config] The config. 20475 * @param {Object} [request] The request. 20476 * @param {Object} [response] The response. 20477 * @returns {Error} The created error. 20478 */ 20479function AxiosError(message, code, config, request, response) { 20480 Error.call(this); 20481 this.message = message; 20482 this.name = 'AxiosError'; 20483 code && (this.code = code); 20484 config && (this.config = config); 20485 request && (this.request = request); 20486 response && (this.response = response); 20487} 20488 20489utils.inherits(AxiosError, Error, { 20490 toJSON: function toJSON() { 20491 return { 20492 // Standard 20493 message: this.message, 20494 name: this.name, 20495 // Microsoft 20496 description: this.description, 20497 number: this.number, 20498 // Mozilla 20499 fileName: this.fileName, 20500 lineNumber: this.lineNumber, 20501 columnNumber: this.columnNumber, 20502 stack: this.stack, 20503 // Axios 20504 config: this.config, 20505 code: this.code, 20506 status: this.response && this.response.status ? this.response.status : null 20507 }; 20508 } 20509}); 20510 20511var prototype = AxiosError.prototype; 20512var descriptors = {}; 20513 20514[ 20515 'ERR_BAD_OPTION_VALUE', 20516 'ERR_BAD_OPTION', 20517 'ECONNABORTED', 20518 'ETIMEDOUT', 20519 'ERR_NETWORK', 20520 'ERR_FR_TOO_MANY_REDIRECTS', 20521 'ERR_DEPRECATED', 20522 'ERR_BAD_RESPONSE', 20523 'ERR_BAD_REQUEST', 20524 'ERR_CANCELED' 20525// eslint-disable-next-line func-names 20526].forEach(function(code) { 20527 descriptors[code] = {value: code}; 20528}); 20529 20530Object.defineProperties(AxiosError, descriptors); 20531Object.defineProperty(prototype, 'isAxiosError', {value: true}); 20532 20533// eslint-disable-next-line func-names 20534AxiosError.from = function(error, code, config, request, response, customProps) { 20535 var axiosError = Object.create(prototype); 20536 20537 utils.toFlatObject(error, axiosError, function filter(obj) { 20538 return obj !== Error.prototype; 20539 }); 20540 20541 AxiosError.call(axiosError, error.message, code, config, request, response); 20542 20543 axiosError.name = error.name; 20544 20545 customProps && Object.assign(axiosError, customProps); 20546 20547 return axiosError; 20548}; 20549 20550module.exports = AxiosError; 20551 20552 20553/***/ }), 20554
vendor: 1,759 bytes, lines 20555-20619
20555/***/ "./node_modules/axios/lib/core/InterceptorManager.js": 20556/*!***********************************************************!*\ 20557 !*** ./node_modules/axios/lib/core/InterceptorManager.js ***! 20558 \***********************************************************/ 20559/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20560 20561"use strict"; 20562 20563 20564var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 20565 20566function InterceptorManager() { 20567 this.handlers = []; 20568} 20569 20570/** 20571 * Add a new interceptor to the stack 20572 * 20573 * @param {Function} fulfilled The function to handle `then` for a `Promise` 20574 * @param {Function} rejected The function to handle `reject` for a `Promise` 20575 * 20576 * @return {Number} An ID used to remove interceptor later 20577 */ 20578InterceptorManager.prototype.use = function use(fulfilled, rejected, options) { 20579 this.handlers.push({ 20580 fulfilled: fulfilled, 20581 rejected: rejected, 20582 synchronous: options ? options.synchronous : false, 20583 runWhen: options ? options.runWhen : null 20584 }); 20585 return this.handlers.length - 1; 20586}; 20587 20588/** 20589 * Remove an interceptor from the stack 20590 * 20591 * @param {Number} id The ID that was returned by `use` 20592 */ 20593InterceptorManager.prototype.eject = function eject(id) { 20594 if (this.handlers[id]) { 20595 this.handlers[id] = null; 20596 } 20597}; 20598 20599/** 20600 * Iterate over all the registered interceptors 20601 * 20602 * This method is particularly useful for skipping over any 20603 * interceptors that may have become `null` calling `eject`. 20604 * 20605 * @param {Function} fn The function to call for each interceptor 20606 */ 20607InterceptorManager.prototype.forEach = function forEach(fn) { 20608 utils.forEach(this.handlers, function forEachHandler(h) { 20609 if (h !== null) { 20610 fn(h); 20611 } 20612 }); 20613}; 20614 20615module.exports = InterceptorManager; 20616 20617 20618/***/ }), 20619
vendor: 1,154 bytes, lines 20620-20650
20620/***/ "./node_modules/axios/lib/core/buildFullPath.js": 20621/*!******************************************************!*\ 20622 !*** ./node_modules/axios/lib/core/buildFullPath.js ***! 20623 \******************************************************/ 20624/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20625 20626"use strict"; 20627 20628 20629var isAbsoluteURL = __webpack_require__(/*! ../helpers/isAbsoluteURL */ "./node_modules/axios/lib/helpers/isAbsoluteURL.js"); 20630var combineURLs = __webpack_require__(/*! ../helpers/combineURLs */ "./node_modules/axios/lib/helpers/combineURLs.js"); 20631 20632/** 20633 * Creates a new URL by combining the baseURL with the requestedURL, 20634 * only when the requestedURL is not already an absolute URL. 20635 * If the requestURL is absolute, this function returns the requestedURL untouched. 20636 * 20637 * @param {string} baseURL The base URL 20638 * @param {string} requestedURL Absolute or relative URL to combine 20639 * @returns {string} The combined full path 20640 */ 20641module.exports = function buildFullPath(baseURL, requestedURL) { 20642 if (baseURL && !isAbsoluteURL(requestedURL)) { 20643 return combineURLs(baseURL, requestedURL); 20644 } 20645 return requestedURL; 20646}; 20647 20648 20649/***/ }), 20650
vendor: 2,783 bytes, lines 20651-20748
20651/***/ "./node_modules/axios/lib/core/dispatchRequest.js": 20652/*!********************************************************!*\ 20653 !*** ./node_modules/axios/lib/core/dispatchRequest.js ***! 20654 \********************************************************/ 20655/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20656 20657"use strict"; 20658 20659 20660var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 20661var transformData = __webpack_require__(/*! ./transformData */ "./node_modules/axios/lib/core/transformData.js"); 20662var isCancel = __webpack_require__(/*! ../cancel/isCancel */ "./node_modules/axios/lib/cancel/isCancel.js"); 20663var defaults = __webpack_require__(/*! ../defaults */ "./node_modules/axios/lib/defaults/index.js"); 20664var CanceledError = __webpack_require__(/*! ../cancel/CanceledError */ "./node_modules/axios/lib/cancel/CanceledError.js"); 20665 20666/** 20667 * Throws a `CanceledError` if cancellation has been requested. 20668 */ 20669function throwIfCancellationRequested(config) { 20670 if (config.cancelToken) { 20671 config.cancelToken.throwIfRequested(); 20672 } 20673 20674 if (config.signal && config.signal.aborted) { 20675 throw new CanceledError(); 20676 } 20677} 20678 20679/** 20680 * Dispatch a request to the server using the configured adapter. 20681 * 20682 * @param {object} config The config that is to be used for the request 20683 * @returns {Promise} The Promise to be fulfilled 20684 */ 20685module.exports = function dispatchRequest(config) { 20686 throwIfCancellationRequested(config); 20687 20688 // Ensure headers exist 20689 config.headers = config.headers || {}; 20690 20691 // Transform request data 20692 config.data = transformData.call( 20693 config, 20694 config.data, 20695 config.headers, 20696 config.transformRequest 20697 ); 20698 20699 // Flatten headers 20700 config.headers = utils.merge( 20701 config.headers.common || {}, 20702 config.headers[config.method] || {}, 20703 config.headers 20704 ); 20705 20706 utils.forEach( 20707 ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], 20708 function cleanHeaderConfig(method) { 20709 delete config.headers[method]; 20710 } 20711 ); 20712 20713 var adapter = config.adapter || defaults.adapter; 20714 20715 return adapter(config).then(function onAdapterResolution(response) { 20716 throwIfCancellationRequested(config); 20717 20718 // Transform response data 20719 response.data = transformData.call( 20720 config, 20721 response.data, 20722 response.headers, 20723 config.transformResponse 20724 ); 20725 20726 return response; 20727 }, function onAdapterRejection(reason) { 20728 if (!isCancel(reason)) { 20729 throwIfCancellationRequested(config); 20730 20731 // Transform response data 20732 if (reason && reason.response) { 20733 reason.response.data = transformData.call( 20734 config, 20735 reason.response.data, 20736 reason.response.headers, 20737 config.transformResponse 20738 ); 20739 } 20740 } 20741 20742 return Promise.reject(reason); 20743 }); 20744}; 20745 20746 20747/***/ }), 20748
vendor: 3,603 bytes, lines 20749-20859
20749/***/ "./node_modules/axios/lib/core/mergeConfig.js": 20750/*!****************************************************!*\ 20751 !*** ./node_modules/axios/lib/core/mergeConfig.js ***! 20752 \****************************************************/ 20753/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20754 20755"use strict"; 20756 20757 20758var utils = __webpack_require__(/*! ../utils */ "./node_modules/axios/lib/utils.js"); 20759 20760/** 20761 * Config-specific merge-function which creates a new config-object 20762 * by merging two configuration objects together. 20763 * 20764 * @param {Object} config1 20765 * @param {Object} config2 20766 * @returns {Object} New object resulting from merging config2 to config1 20767 */ 20768module.exports = function mergeConfig(config1, config2) { 20769 // eslint-disable-next-line no-param-reassign 20770 config2 = config2 || {}; 20771 var config = {}; 20772 20773 function getMergedValue(target, source) { 20774 if (utils.isPlainObject(target) && utils.isPlainObject(source)) { 20775 return utils.merge(target, source); 20776 } else if (utils.isPlainObject(source)) { 20777 return utils.merge({}, source); 20778 } else if (utils.isArray(source)) { 20779 return source.slice(); 20780 } 20781 return source; 20782 } 20783 20784 // eslint-disable-next-line consistent-return 20785 function mergeDeepProperties(prop) { 20786 if (!utils.isUndefined(config2[prop])) { 20787 return getMergedValue(config1[prop], config2[prop]); 20788 } else if (!utils.isUndefined(config1[prop])) { 20789 return getMergedValue(undefined, config1[prop]); 20790 } 20791 } 20792 20793 // eslint-disable-next-line consistent-return 20794 function valueFromConfig2(prop) { 20795 if (!utils.isUndefined(config2[prop])) { 20796 return getMergedValue(undefined, config2[prop]); 20797 } 20798 } 20799 20800 // eslint-disable-next-line consistent-return 20801 function defaultToConfig2(prop) { 20802 if (!utils.isUndefined(config2[prop])) { 20803 return getMergedValue(undefined, config2[prop]); 20804 } else if (!utils.isUndefined(config1[prop])) { 20805 return getMergedValue(undefined, config1[prop]); 20806 } 20807 } 20808 20809 // eslint-disable-next-line consistent-return 20810 function mergeDirectKeys(prop) { 20811 if (prop in config2) { 20812 return getMergedValue(config1[prop], config2[prop]); 20813 } else if (prop in config1) { 20814 return getMergedValue(undefined, config1[prop]); 20815 } 20816 } 20817 20818 var mergeMap = { 20819 'url': valueFromConfig2, 20820 'method': valueFromConfig2, 20821 'data': valueFromConfig2, 20822 'baseURL': defaultToConfig2, 20823 'transformRequest': defaultToConfig2, 20824 'transformResponse': defaultToConfig2, 20825 'paramsSerializer': defaultToConfig2, 20826 'timeout': defaultToConfig2, 20827 'timeoutMessage': defaultToConfig2, 20828 'withCredentials': defaultToConfig2, 20829 'adapter': defaultToConfig2, 20830 'responseType': defaultToConfig2, 20831 'xsrfCookieName': defaultToConfig2, 20832 'xsrfHeaderName': defaultToConfig2, 20833 'onUploadProgress': defaultToConfig2, 20834 'onDownloadProgress': defaultToConfig2, 20835 'decompress': defaultToConfig2, 20836 'maxContentLength': defaultToConfig2, 20837 'maxBodyLength': defaultToConfig2, 20838 'beforeRedirect': defaultToConfig2, 20839 'transport': defaultToConfig2, 20840 'httpAgent': defaultToConfig2, 20841 'httpsAgent': defaultToConfig2, 20842 'cancelToken': defaultToConfig2, 20843 'socketPath': defaultToConfig2, 20844 'responseEncoding': defaultToConfig2, 20845 'validateStatus': mergeDirectKeys 20846 }; 20847 20848 utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) { 20849 var merge = mergeMap[prop] || mergeDeepProperties; 20850 var configValue = merge(prop); 20851 (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue); 20852 }); 20853 20854 return config; 20855}; 20856 20857 20858/***/ }), 20859
vendor: 1,157 bytes, lines 20860-20895
20860/***/ "./node_modules/axios/lib/core/settle.js": 20861/*!***********************************************!*\ 20862 !*** ./node_modules/axios/lib/core/settle.js ***! 20863 \***********************************************/ 20864/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20865 20866"use strict"; 20867 20868 20869var AxiosError = __webpack_require__(/*! ./AxiosError */ "./node_modules/axios/lib/core/AxiosError.js"); 20870 20871/** 20872 * Resolve or reject a Promise based on response status. 20873 * 20874 * @param {Function} resolve A function that resolves the promise. 20875 * @param {Function} reject A function that rejects the promise. 20876 * @param {object} response The response. 20877 */ 20878module.exports = function settle(resolve, reject, response) { 20879 var validateStatus = response.config.validateStatus; 20880 if (!response.status || !validateStatus || validateStatus(response.status)) { 20881 resolve(response); 20882 } else { 20883 reject(new AxiosError( 20884 'Request failed with status code ' + response.status, 20885 [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4], 20886 response.config, 20887 response.request, 20888 response 20889 )); 20890 } 20891}; 20892 20893 20894/***/ }), 20895
vendor: 1,075 bytes, lines 20896-20928
20896/***/ "./node_modules/axios/lib/core/transformData.js": 20897/*!******************************************************!*\ 20898 !*** ./node_modules/axios/lib/core/transformData.js ***! 20899 \******************************************************/ 20900/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20901 20902"use strict"; 20903 20904 20905var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 20906var defaults = __webpack_require__(/*! ../defaults */ "./node_modules/axios/lib/defaults/index.js"); 20907 20908/** 20909 * Transform the data for a request or a response 20910 * 20911 * @param {Object|String} data The data to be transformed 20912 * @param {Array} headers The headers for the request or response 20913 * @param {Array|Function} fns A single function or Array of functions 20914 * @returns {*} The resulting transformed data 20915 */ 20916module.exports = function transformData(data, headers, fns) { 20917 var context = this || defaults; 20918 /*eslint no-param-reassign:0*/ 20919 utils.forEach(fns, function transform(fn) { 20920 data = fn.call(context, data, headers); 20921 }); 20922 20923 return data; 20924}; 20925 20926 20927/***/ }), 20928
vendor: 5,008 bytes, lines 20929-21086
20929/***/ "./node_modules/axios/lib/defaults/index.js": 20930/*!**************************************************!*\ 20931 !*** ./node_modules/axios/lib/defaults/index.js ***! 20932 \**************************************************/ 20933/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 20934 20935"use strict"; 20936/* provided dependency */ var process = __webpack_require__(/*! process/browser.js */ "./node_modules/process/browser.js"); 20937 20938 20939var utils = __webpack_require__(/*! ../utils */ "./node_modules/axios/lib/utils.js"); 20940var normalizeHeaderName = __webpack_require__(/*! ../helpers/normalizeHeaderName */ "./node_modules/axios/lib/helpers/normalizeHeaderName.js"); 20941var AxiosError = __webpack_require__(/*! ../core/AxiosError */ "./node_modules/axios/lib/core/AxiosError.js"); 20942var transitionalDefaults = __webpack_require__(/*! ./transitional */ "./node_modules/axios/lib/defaults/transitional.js"); 20943var toFormData = __webpack_require__(/*! ../helpers/toFormData */ "./node_modules/axios/lib/helpers/toFormData.js"); 20944 20945var DEFAULT_CONTENT_TYPE = { 20946 'Content-Type': 'application/x-www-form-urlencoded' 20947}; 20948 20949function setContentTypeIfUnset(headers, value) { 20950 if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) { 20951 headers['Content-Type'] = value; 20952 } 20953} 20954 20955function getDefaultAdapter() { 20956 var adapter; 20957 if (typeof XMLHttpRequest !== 'undefined') { 20958 // For browsers use XHR adapter 20959 adapter = __webpack_require__(/*! ../adapters/xhr */ "./node_modules/axios/lib/adapters/xhr.js"); 20960 } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') { 20961 // For node use HTTP adapter 20962 adapter = __webpack_require__(/*! ../adapters/http */ "./node_modules/axios/lib/adapters/xhr.js"); 20963 } 20964 return adapter; 20965} 20966 20967function stringifySafely(rawValue, parser, encoder) { 20968 if (utils.isString(rawValue)) { 20969 try { 20970 (parser || JSON.parse)(rawValue); 20971 return utils.trim(rawValue); 20972 } catch (e) { 20973 if (e.name !== 'SyntaxError') { 20974 throw e; 20975 } 20976 } 20977 } 20978 20979 return (encoder || JSON.stringify)(rawValue); 20980} 20981 20982var defaults = { 20983 20984 transitional: transitionalDefaults, 20985 20986 adapter: getDefaultAdapter(), 20987 20988 transformRequest: [function transformRequest(data, headers) { 20989 normalizeHeaderName(headers, 'Accept'); 20990 normalizeHeaderName(headers, 'Content-Type'); 20991 20992 if (utils.isFormData(data) || 20993 utils.isArrayBuffer(data) || 20994 utils.isBuffer(data) || 20995 utils.isStream(data) || 20996 utils.isFile(data) || 20997 utils.isBlob(data) 20998 ) { 20999 return data; 21000 } 21001 if (utils.isArrayBufferView(data)) { 21002 return data.buffer; 21003 } 21004 if (utils.isURLSearchParams(data)) { 21005 setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8'); 21006 return data.toString(); 21007 } 21008 21009 var isObjectPayload = utils.isObject(data); 21010 var contentType = headers && headers['Content-Type']; 21011 21012 var isFileList; 21013 21014 if ((isFileList = utils.isFileList(data)) || (isObjectPayload && contentType === 'multipart/form-data')) { 21015 var _FormData = this.env && this.env.FormData; 21016 return toFormData(isFileList ? {'files[]': data} : data, _FormData && new _FormData()); 21017 } else if (isObjectPayload || contentType === 'application/json') { 21018 setContentTypeIfUnset(headers, 'application/json'); 21019 return stringifySafely(data); 21020 } 21021 21022 return data; 21023 }], 21024 21025 transformResponse: [function transformResponse(data) { 21026 var transitional = this.transitional || defaults.transitional; 21027 var silentJSONParsing = transitional && transitional.silentJSONParsing; 21028 var forcedJSONParsing = transitional && transitional.forcedJSONParsing; 21029 var strictJSONParsing = !silentJSONParsing && this.responseType === 'json'; 21030 21031 if (strictJSONParsing || (forcedJSONParsing && utils.isString(data) && data.length)) { 21032 try { 21033 return JSON.parse(data); 21034 } catch (e) { 21035 if (strictJSONParsing) { 21036 if (e.name === 'SyntaxError') { 21037 throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response); 21038 } 21039 throw e; 21040 } 21041 } 21042 } 21043 21044 return data; 21045 }], 21046 21047 /** 21048 * A timeout in milliseconds to abort a request. If set to 0 (default) a 21049 * timeout is not created. 21050 */ 21051 timeout: 0, 21052 21053 xsrfCookieName: 'XSRF-TOKEN', 21054 xsrfHeaderName: 'X-XSRF-TOKEN', 21055 21056 maxContentLength: -1, 21057 maxBodyLength: -1, 21058 21059 env: { 21060 FormData: __webpack_require__(/*! ./env/FormData */ "./node_modules/axios/lib/helpers/null.js") 21061 }, 21062 21063 validateStatus: function validateStatus(status) { 21064 return status >= 200 && status < 300; 21065 }, 21066 21067 headers: { 21068 common: { 21069 'Accept': 'application/json, text/plain, */*' 21070 } 21071 } 21072}; 21073 21074utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) { 21075 defaults.headers[method] = {}; 21076}); 21077 21078utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { 21079 defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE); 21080}); 21081 21082module.exports = defaults; 21083 21084 21085/***/ }), 21086
vendor: 408 bytes, lines 21087-21104
21087/***/ "./node_modules/axios/lib/defaults/transitional.js": 21088/*!*********************************************************!*\ 21089 !*** ./node_modules/axios/lib/defaults/transitional.js ***! 21090 \*********************************************************/ 21091/***/ (function(module) { 21092 21093"use strict"; 21094 21095 21096module.exports = { 21097 silentJSONParsing: true, 21098 forcedJSONParsing: true, 21099 clarifyTimeoutError: false 21100}; 21101 21102 21103/***/ }), 21104
vendor: 278 bytes, lines 21105-21116
21105/***/ "./node_modules/axios/lib/env/data.js": 21106/*!********************************************!*\ 21107 !*** ./node_modules/axios/lib/env/data.js ***! 21108 \********************************************/ 21109/***/ (function(module) { 21110 21111module.exports = { 21112 "version": "0.27.2" 21113}; 21114 21115/***/ }), 21116
vendor: 508 bytes, lines 21117-21138
21117/***/ "./node_modules/axios/lib/helpers/bind.js": 21118/*!************************************************!*\ 21119 !*** ./node_modules/axios/lib/helpers/bind.js ***! 21120 \************************************************/ 21121/***/ (function(module) { 21122 21123"use strict"; 21124 21125 21126module.exports = function bind(fn, thisArg) { 21127 return function wrap() { 21128 var args = new Array(arguments.length); 21129 for (var i = 0; i < args.length; i++) { 21130 args[i] = arguments[i]; 21131 } 21132 return fn.apply(thisArg, args); 21133 }; 21134}; 21135 21136 21137/***/ }), 21138
vendor: 2,012 bytes, lines 21139-21219
21139/***/ "./node_modules/axios/lib/helpers/buildURL.js": 21140/*!****************************************************!*\ 21141 !*** ./node_modules/axios/lib/helpers/buildURL.js ***! 21142 \****************************************************/ 21143/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 21144 21145"use strict"; 21146 21147 21148var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 21149 21150function encode(val) { 21151 return encodeURIComponent(val). 21152 replace(/%3A/gi, ':'). 21153 replace(/%24/g, '$'). 21154 replace(/%2C/gi, ','). 21155 replace(/%20/g, '+'). 21156 replace(/%5B/gi, '['). 21157 replace(/%5D/gi, ']'); 21158} 21159 21160/** 21161 * Build a URL by appending params to the end 21162 * 21163 * @param {string} url The base of the url (e.g., http://www.google.com) 21164 * @param {object} [params] The params to be appended 21165 * @returns {string} The formatted url 21166 */ 21167module.exports = function buildURL(url, params, paramsSerializer) { 21168 /*eslint no-param-reassign:0*/ 21169 if (!params) { 21170 return url; 21171 } 21172 21173 var serializedParams; 21174 if (paramsSerializer) { 21175 serializedParams = paramsSerializer(params); 21176 } else if (utils.isURLSearchParams(params)) { 21177 serializedParams = params.toString(); 21178 } else { 21179 var parts = []; 21180 21181 utils.forEach(params, function serialize(val, key) { 21182 if (val === null || typeof val === 'undefined') { 21183 return; 21184 } 21185 21186 if (utils.isArray(val)) { 21187 key = key + '[]'; 21188 } else { 21189 val = [val]; 21190 } 21191 21192 utils.forEach(val, function parseValue(v) { 21193 if (utils.isDate(v)) { 21194 v = v.toISOString(); 21195 } else if (utils.isObject(v)) { 21196 v = JSON.stringify(v); 21197 } 21198 parts.push(encode(key) + '=' + encode(v)); 21199 }); 21200 }); 21201 21202 serializedParams = parts.join('&'); 21203 } 21204 21205 if (serializedParams) { 21206 var hashmarkIndex = url.indexOf('#'); 21207 if (hashmarkIndex !== -1) { 21208 url = url.slice(0, hashmarkIndex); 21209 } 21210 21211 url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams; 21212 } 21213 21214 return url; 21215}; 21216 21217 21218/***/ }), 21219
vendor: 660 bytes, lines 21220-21244
21220/***/ "./node_modules/axios/lib/helpers/combineURLs.js": 21221/*!*******************************************************!*\ 21222 !*** ./node_modules/axios/lib/helpers/combineURLs.js ***! 21223 \*******************************************************/ 21224/***/ (function(module) { 21225 21226"use strict"; 21227 21228 21229/** 21230 * Creates a new URL by combining the specified URLs 21231 * 21232 * @param {string} baseURL The base URL 21233 * @param {string} relativeURL The relative URL 21234 * @returns {string} The combined URL 21235 */ 21236module.exports = function combineURLs(baseURL, relativeURL) { 21237 return relativeURL 21238 ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '') 21239 : baseURL; 21240}; 21241 21242 21243/***/ }), 21244
vendor: 1,799 bytes, lines 21245-21308
21245/***/ "./node_modules/axios/lib/helpers/cookies.js": 21246/*!***************************************************!*\ 21247 !*** ./node_modules/axios/lib/helpers/cookies.js ***! 21248 \***************************************************/ 21249/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 21250 21251"use strict"; 21252 21253 21254var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 21255 21256module.exports = ( 21257 utils.isStandardBrowserEnv() ? 21258 21259 // Standard browser envs support document.cookie 21260 (function standardBrowserEnv() { 21261 return { 21262 write: function write(name, value, expires, path, domain, secure) { 21263 var cookie = []; 21264 cookie.push(name + '=' + encodeURIComponent(value)); 21265 21266 if (utils.isNumber(expires)) { 21267 cookie.push('expires=' + new Date(expires).toGMTString()); 21268 } 21269 21270 if (utils.isString(path)) { 21271 cookie.push('path=' + path); 21272 } 21273 21274 if (utils.isString(domain)) { 21275 cookie.push('domain=' + domain); 21276 } 21277 21278 if (secure === true) { 21279 cookie.push('secure'); 21280 } 21281 21282 document.cookie = cookie.join('; '); 21283 }, 21284 21285 read: function read(name) { 21286 var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)')); 21287 return (match ? decodeURIComponent(match[3]) : null); 21288 }, 21289 21290 remove: function remove(name) { 21291 this.write(name, '', Date.now() - 86400000); 21292 } 21293 }; 21294 })() : 21295 21296 // Non standard browser env (web workers, react-native) lack needed support. 21297 (function nonStandardBrowserEnv() { 21298 return { 21299 write: function write() {}, 21300 read: function read() { return null; }, 21301 remove: function remove() {} 21302 }; 21303 })() 21304); 21305 21306 21307/***/ }), 21308
vendor: 849 bytes, lines 21309-21333
21309/***/ "./node_modules/axios/lib/helpers/isAbsoluteURL.js": 21310/*!*********************************************************!*\ 21311 !*** ./node_modules/axios/lib/helpers/isAbsoluteURL.js ***! 21312 \*********************************************************/ 21313/***/ (function(module) { 21314 21315"use strict"; 21316 21317 21318/** 21319 * Determines whether the specified URL is absolute 21320 * 21321 * @param {string} url The URL to test 21322 * @returns {boolean} True if the specified URL is absolute, otherwise false 21323 */ 21324module.exports = function isAbsoluteURL(url) { 21325 // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL). 21326 // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed 21327 // by any combination of letters, digits, plus, period, or hyphen. 21328 return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url); 21329}; 21330 21331 21332/***/ }), 21333
vendor: 757 bytes, lines 21334-21357
21334/***/ "./node_modules/axios/lib/helpers/isAxiosError.js": 21335/*!********************************************************!*\ 21336 !*** ./node_modules/axios/lib/helpers/isAxiosError.js ***! 21337 \********************************************************/ 21338/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 21339 21340"use strict"; 21341 21342 21343var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 21344 21345/** 21346 * Determines whether the payload is an error thrown by Axios 21347 * 21348 * @param {*} payload The value to test 21349 * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false 21350 */ 21351module.exports = function isAxiosError(payload) { 21352 return utils.isObject(payload) && (payload.isAxiosError === true); 21353}; 21354 21355 21356/***/ }), 21357
vendor: 2,701 bytes, lines 21358-21436
21358/***/ "./node_modules/axios/lib/helpers/isURLSameOrigin.js": 21359/*!***********************************************************!*\ 21360 !*** ./node_modules/axios/lib/helpers/isURLSameOrigin.js ***! 21361 \***********************************************************/ 21362/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 21363 21364"use strict"; 21365 21366 21367var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 21368 21369module.exports = ( 21370 utils.isStandardBrowserEnv() ? 21371 21372 // Standard browser envs have full support of the APIs needed to test 21373 // whether the request URL is of the same origin as current location. 21374 (function standardBrowserEnv() { 21375 var msie = /(msie|trident)/i.test(navigator.userAgent); 21376 var urlParsingNode = document.createElement('a'); 21377 var originURL; 21378 21379 /** 21380 * Parse a URL to discover it's components 21381 * 21382 * @param {String} url The URL to be parsed 21383 * @returns {Object} 21384 */ 21385 function resolveURL(url) { 21386 var href = url; 21387 21388 if (msie) { 21389 // IE needs attribute set twice to normalize properties 21390 urlParsingNode.setAttribute('href', href); 21391 href = urlParsingNode.href; 21392 } 21393 21394 urlParsingNode.setAttribute('href', href); 21395 21396 // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils 21397 return { 21398 href: urlParsingNode.href, 21399 protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '', 21400 host: urlParsingNode.host, 21401 search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '', 21402 hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '', 21403 hostname: urlParsingNode.hostname, 21404 port: urlParsingNode.port, 21405 pathname: (urlParsingNode.pathname.charAt(0) === '/') ? 21406 urlParsingNode.pathname : 21407 '/' + urlParsingNode.pathname 21408 }; 21409 } 21410 21411 originURL = resolveURL(window.location.href); 21412 21413 /** 21414 * Determine if a URL shares the same origin as the current location 21415 * 21416 * @param {String} requestURL The URL to test 21417 * @returns {boolean} True if URL shares the same origin, otherwise false 21418 */ 21419 return function isURLSameOrigin(requestURL) { 21420 var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL; 21421 return (parsed.protocol === originURL.protocol && 21422 parsed.host === originURL.host); 21423 }; 21424 })() : 21425 21426 // Non standard browser envs (web workers, react-native) lack needed support. 21427 (function nonStandardBrowserEnv() { 21428 return function isURLSameOrigin() { 21429 return true; 21430 }; 21431 })() 21432); 21433 21434 21435/***/ }), 21436
vendor: 769 bytes, lines 21437-21459
21437/***/ "./node_modules/axios/lib/helpers/normalizeHeaderName.js": 21438/*!***************************************************************!*\ 21439 !*** ./node_modules/axios/lib/helpers/normalizeHeaderName.js ***! 21440 \***************************************************************/ 21441/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 21442 21443"use strict"; 21444 21445 21446var utils = __webpack_require__(/*! ../utils */ "./node_modules/axios/lib/utils.js"); 21447 21448module.exports = function normalizeHeaderName(headers, normalizedName) { 21449 utils.forEach(headers, function processHeader(value, name) { 21450 if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) { 21451 headers[normalizedName] = value; 21452 delete headers[name]; 21453 } 21454 }); 21455}; 21456 21457 21458/***/ }), 21459
vendor: 309 bytes, lines 21460-21471
21460/***/ "./node_modules/axios/lib/helpers/null.js": 21461/*!************************************************!*\ 21462 !*** ./node_modules/axios/lib/helpers/null.js ***! 21463 \************************************************/ 21464/***/ (function(module) { 21465 21466// eslint-disable-next-line strict 21467module.exports = null; 21468 21469 21470/***/ }), 21471
vendor: 1,777 bytes, lines 21472-21535
21472/***/ "./node_modules/axios/lib/helpers/parseHeaders.js": 21473/*!********************************************************!*\ 21474 !*** ./node_modules/axios/lib/helpers/parseHeaders.js ***! 21475 \********************************************************/ 21476/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 21477 21478"use strict"; 21479 21480 21481var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 21482 21483// Headers whose duplicates are ignored by node 21484// c.f. https://nodejs.org/api/http.html#http_message_headers 21485var ignoreDuplicateOf = [ 21486 'age', 'authorization', 'content-length', 'content-type', 'etag', 21487 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since', 21488 'last-modified', 'location', 'max-forwards', 'proxy-authorization', 21489 'referer', 'retry-after', 'user-agent' 21490]; 21491 21492/** 21493 * Parse headers into an object 21494 * 21495 * ``` 21496 * Date: Wed, 27 Aug 2014 08:58:49 GMT 21497 * Content-Type: application/json 21498 * Connection: keep-alive 21499 * Transfer-Encoding: chunked 21500 * ``` 21501 * 21502 * @param {String} headers Headers needing to be parsed 21503 * @returns {Object} Headers parsed into an object 21504 */ 21505module.exports = function parseHeaders(headers) { 21506 var parsed = {}; 21507 var key; 21508 var val; 21509 var i; 21510 21511 if (!headers) { return parsed; } 21512 21513 utils.forEach(headers.split('\n'), function parser(line) { 21514 i = line.indexOf(':'); 21515 key = utils.trim(line.substr(0, i)).toLowerCase(); 21516 val = utils.trim(line.substr(i + 1)); 21517 21518 if (key) { 21519 if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) { 21520 return; 21521 } 21522 if (key === 'set-cookie') { 21523 parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]); 21524 } else { 21525 parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val; 21526 } 21527 } 21528 }); 21529 21530 return parsed; 21531}; 21532 21533 21534/***/ }), 21535
vendor: 440 bytes, lines 21536-21552
21536/***/ "./node_modules/axios/lib/helpers/parseProtocol.js": 21537/*!*********************************************************!*\ 21538 !*** ./node_modules/axios/lib/helpers/parseProtocol.js ***! 21539 \*********************************************************/ 21540/***/ (function(module) { 21541 21542"use strict"; 21543 21544 21545module.exports = function parseProtocol(url) { 21546 var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url); 21547 return match && match[1] || ''; 21548}; 21549 21550 21551/***/ }), 21552
vendor: 824 bytes, lines 21553-21590
21553/***/ "./node_modules/axios/lib/helpers/spread.js": 21554/*!**************************************************!*\ 21555 !*** ./node_modules/axios/lib/helpers/spread.js ***! 21556 \**************************************************/ 21557/***/ (function(module) { 21558 21559"use strict"; 21560 21561 21562/** 21563 * Syntactic sugar for invoking a function and expanding an array for arguments. 21564 * 21565 * Common use case would be to use `Function.prototype.apply`. 21566 * 21567 * ```js 21568 * function f(x, y, z) {} 21569 * var args = [1, 2, 3]; 21570 * f.apply(null, args); 21571 * ``` 21572 * 21573 * With `spread` this example can be re-written. 21574 * 21575 * ```js 21576 * spread(function(x, y, z) {})([1, 2, 3]); 21577 * ``` 21578 * 21579 * @param {Function} callback 21580 * @returns {Function} 21581 */ 21582module.exports = function spread(callback) { 21583 return function wrap(arr) { 21584 return callback.apply(null, arr); 21585 }; 21586}; 21587 21588 21589/***/ }), 21590
vendor: 2,278 bytes, lines 21591-21674
21591/***/ "./node_modules/axios/lib/helpers/toFormData.js": 21592/*!******************************************************!*\ 21593 !*** ./node_modules/axios/lib/helpers/toFormData.js ***! 21594 \******************************************************/ 21595/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 21596 21597"use strict"; 21598/* provided dependency */ var Buffer = __webpack_require__(/*! buffer */ "./node_modules/buffer/index.js")["Buffer"]; 21599 21600 21601var utils = __webpack_require__(/*! ../utils */ "./node_modules/axios/lib/utils.js"); 21602 21603/** 21604 * Convert a data object to FormData 21605 * @param {Object} obj 21606 * @param {?Object} [formData] 21607 * @returns {Object} 21608 **/ 21609 21610function toFormData(obj, formData) { 21611 // eslint-disable-next-line no-param-reassign 21612 formData = formData || new FormData(); 21613 21614 var stack = []; 21615 21616 function convertValue(value) { 21617 if (value === null) return ''; 21618 21619 if (utils.isDate(value)) { 21620 return value.toISOString(); 21621 } 21622 21623 if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) { 21624 return typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value); 21625 } 21626 21627 return value; 21628 } 21629 21630 function build(data, parentKey) { 21631 if (utils.isPlainObject(data) || utils.isArray(data)) { 21632 if (stack.indexOf(data) !== -1) { 21633 throw Error('Circular reference detected in ' + parentKey); 21634 } 21635 21636 stack.push(data); 21637 21638 utils.forEach(data, function each(value, key) { 21639 if (utils.isUndefined(value)) return; 21640 var fullKey = parentKey ? parentKey + '.' + key : key; 21641 var arr; 21642 21643 if (value && !parentKey && typeof value === 'object') { 21644 if (utils.endsWith(key, '{}')) { 21645 // eslint-disable-next-line no-param-reassign 21646 value = JSON.stringify(value); 21647 } else if (utils.endsWith(key, '[]') && (arr = utils.toArray(value))) { 21648 // eslint-disable-next-line func-names 21649 arr.forEach(function(el) { 21650 !utils.isUndefined(el) && formData.append(fullKey, convertValue(el)); 21651 }); 21652 return; 21653 } 21654 } 21655 21656 build(value, fullKey); 21657 }); 21658 21659 stack.pop(); 21660 } else { 21661 formData.append(parentKey, convertValue(data)); 21662 } 21663 } 21664 21665 build(obj); 21666 21667 return formData; 21668} 21669 21670module.exports = toFormData; 21671 21672 21673/***/ }), 21674
vendor: 2,995 bytes, lines 21675-21771
21675/***/ "./node_modules/axios/lib/helpers/validator.js": 21676/*!*****************************************************!*\ 21677 !*** ./node_modules/axios/lib/helpers/validator.js ***! 21678 \*****************************************************/ 21679/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 21680 21681"use strict"; 21682 21683 21684var VERSION = (__webpack_require__(/*! ../env/data */ "./node_modules/axios/lib/env/data.js").version); 21685var AxiosError = __webpack_require__(/*! ../core/AxiosError */ "./node_modules/axios/lib/core/AxiosError.js"); 21686 21687var validators = {}; 21688 21689// eslint-disable-next-line func-names 21690['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function(type, i) { 21691 validators[type] = function validator(thing) { 21692 return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type; 21693 }; 21694}); 21695 21696var deprecatedWarnings = {}; 21697 21698/** 21699 * Transitional option validator 21700 * @param {function|boolean?} validator - set to false if the transitional option has been removed 21701 * @param {string?} version - deprecated version / removed since version 21702 * @param {string?} message - some message with additional info 21703 * @returns {function} 21704 */ 21705validators.transitional = function transitional(validator, version, message) { 21706 function formatMessage(opt, desc) { 21707 return '[Axios v' + VERSION + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : ''); 21708 } 21709 21710 // eslint-disable-next-line func-names 21711 return function(value, opt, opts) { 21712 if (validator === false) { 21713 throw new AxiosError( 21714 formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')), 21715 AxiosError.ERR_DEPRECATED 21716 ); 21717 } 21718 21719 if (version && !deprecatedWarnings[opt]) { 21720 deprecatedWarnings[opt] = true; 21721 // eslint-disable-next-line no-console 21722 console.warn( 21723 formatMessage( 21724 opt, 21725 ' has been deprecated since v' + version + ' and will be removed in the near future' 21726 ) 21727 ); 21728 } 21729 21730 return validator ? validator(value, opt, opts) : true; 21731 }; 21732}; 21733 21734/** 21735 * Assert object's properties type 21736 * @param {object} options 21737 * @param {object} schema 21738 * @param {boolean?} allowUnknown 21739 */ 21740 21741function assertOptions(options, schema, allowUnknown) { 21742 if (typeof options !== 'object') { 21743 throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE); 21744 } 21745 var keys = Object.keys(options); 21746 var i = keys.length; 21747 while (i-- > 0) { 21748 var opt = keys[i]; 21749 var validator = schema[opt]; 21750 if (validator) { 21751 var value = options[opt]; 21752 var result = value === undefined || validator(value, opt, options); 21753 if (result !== true) { 21754 throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE); 21755 } 21756 continue; 21757 } 21758 if (allowUnknown !== true) { 21759 throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION); 21760 } 21761 } 21762} 21763 21764module.exports = { 21765 assertOptions: assertOptions, 21766 validators: validators 21767}; 21768 21769 21770/***/ }), 21771
vendor: 52,792 bytes, lines 21772-22998
21772/***/ "./node_modules/axios/lib/utils.js": 21773/*!*****************************************!*\ 21774 !*** ./node_modules/axios/lib/utils.js ***! 21775 \*****************************************/ 21776/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 21777 21778"use strict"; 21779 21780 21781var bind = __webpack_require__(/*! ./helpers/bind */ "./node_modules/axios/lib/helpers/bind.js"); 21782 21783// utils is a library of generic helper functions non-specific to axios 21784 21785var toString = Object.prototype.toString; 21786 21787// eslint-disable-next-line func-names 21788var kindOf = (function(cache) { 21789 // eslint-disable-next-line func-names 21790 return function(thing) { 21791 var str = toString.call(thing); 21792 return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase()); 21793 }; 21794})(Object.create(null)); 21795 21796function kindOfTest(type) { 21797 type = type.toLowerCase(); 21798 return function isKindOf(thing) { 21799 return kindOf(thing) === type; 21800 }; 21801} 21802 21803/** 21804 * Determine if a value is an Array 21805 * 21806 * @param {Object} val The value to test 21807 * @returns {boolean} True if value is an Array, otherwise false 21808 */ 21809function isArray(val) { 21810 return Array.isArray(val); 21811} 21812 21813/** 21814 * Determine if a value is undefined 21815 * 21816 * @param {Object} val The value to test 21817 * @returns {boolean} True if the value is undefined, otherwise false 21818 */ 21819function isUndefined(val) { 21820 return typeof val === 'undefined'; 21821} 21822 21823/** 21824 * Determine if a value is a Buffer 21825 * 21826 * @param {Object} val The value to test 21827 * @returns {boolean} True if value is a Buffer, otherwise false 21828 */ 21829function isBuffer(val) { 21830 return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) 21831 && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val); 21832} 21833 21834/** 21835 * Determine if a value is an ArrayBuffer 21836 * 21837 * @function 21838 * @param {Object} val The value to test 21839 * @returns {boolean} True if value is an ArrayBuffer, otherwise false 21840 */ 21841var isArrayBuffer = kindOfTest('ArrayBuffer'); 21842 21843 21844/** 21845 * Determine if a value is a view on an ArrayBuffer 21846 * 21847 * @param {Object} val The value to test 21848 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false 21849 */ 21850function isArrayBufferView(val) { 21851 var result; 21852 if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) { 21853 result = ArrayBuffer.isView(val); 21854 } else { 21855 result = (val) && (val.buffer) && (isArrayBuffer(val.buffer)); 21856 } 21857 return result; 21858} 21859 21860/** 21861 * Determine if a value is a String 21862 * 21863 * @param {Object} val The value to test 21864 * @returns {boolean} True if value is a String, otherwise false 21865 */ 21866function isString(val) { 21867 return typeof val === 'string'; 21868} 21869 21870/** 21871 * Determine if a value is a Number 21872 * 21873 * @param {Object} val The value to test 21874 * @returns {boolean} True if value is a Number, otherwise false 21875 */ 21876function isNumber(val) { 21877 return typeof val === 'number'; 21878} 21879 21880/** 21881 * Determine if a value is an Object 21882 * 21883 * @param {Object} val The value to test 21884 * @returns {boolean} True if value is an Object, otherwise false 21885 */ 21886function isObject(val) { 21887 return val !== null && typeof val === 'object'; 21888} 21889 21890/** 21891 * Determine if a value is a plain Object 21892 * 21893 * @param {Object} val The value to test 21894 * @return {boolean} True if value is a plain Object, otherwise false 21895 */ 21896function isPlainObject(val) { 21897 if (kindOf(val) !== 'object') { 21898 return false; 21899 } 21900 21901 var prototype = Object.getPrototypeOf(val); 21902 return prototype === null || prototype === Object.prototype; 21903} 21904 21905/** 21906 * Determine if a value is a Date 21907 * 21908 * @function 21909 * @param {Object} val The value to test 21910 * @returns {boolean} True if value is a Date, otherwise false 21911 */ 21912var isDate = kindOfTest('Date'); 21913 21914/** 21915 * Determine if a value is a File 21916 * 21917 * @function 21918 * @param {Object} val The value to test 21919 * @returns {boolean} True if value is a File, otherwise false 21920 */ 21921var isFile = kindOfTest('File'); 21922 21923/** 21924 * Determine if a value is a Blob 21925 * 21926 * @function 21927 * @param {Object} val The value to test 21928 * @returns {boolean} True if value is a Blob, otherwise false 21929 */ 21930var isBlob = kindOfTest('Blob'); 21931 21932/** 21933 * Determine if a value is a FileList 21934 * 21935 * @function 21936 * @param {Object} val The value to test 21937 * @returns {boolean} True if value is a File, otherwise false 21938 */ 21939var isFileList = kindOfTest('FileList'); 21940 21941/** 21942 * Determine if a value is a Function 21943 * 21944 * @param {Object} val The value to test 21945 * @returns {boolean} True if value is a Function, otherwise false 21946 */ 21947function isFunction(val) { 21948 return toString.call(val) === '[object Function]'; 21949} 21950 21951/** 21952 * Determine if a value is a Stream 21953 * 21954 * @param {Object} val The value to test 21955 * @returns {boolean} True if value is a Stream, otherwise false 21956 */ 21957function isStream(val) { 21958 return isObject(val) && isFunction(val.pipe); 21959} 21960 21961/** 21962 * Determine if a value is a FormData 21963 * 21964 * @param {Object} thing The value to test 21965 * @returns {boolean} True if value is an FormData, otherwise false 21966 */ 21967function isFormData(thing) { 21968 var pattern = '[object FormData]'; 21969 return thing && ( 21970 (typeof FormData === 'function' && thing instanceof FormData) || 21971 toString.call(thing) === pattern || 21972 (isFunction(thing.toString) && thing.toString() === pattern) 21973 ); 21974} 21975 21976/** 21977 * Determine if a value is a URLSearchParams object 21978 * @function 21979 * @param {Object} val The value to test 21980 * @returns {boolean} True if value is a URLSearchParams object, otherwise false 21981 */ 21982var isURLSearchParams = kindOfTest('URLSearchParams'); 21983 21984/** 21985 * Trim excess whitespace off the beginning and end of a string 21986 * 21987 * @param {String} str The String to trim 21988 * @returns {String} The String freed of excess whitespace 21989 */ 21990function trim(str) { 21991 return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, ''); 21992} 21993 21994/** 21995 * Determine if we're running in a standard browser environment 21996 * 21997 * This allows axios to run in a web worker, and react-native. 21998 * Both environments support XMLHttpRequest, but not fully standard globals. 21999 * 22000 * web workers: 22001 * typeof window -> undefined 22002 * typeof document -> undefined 22003 * 22004 * react-native: 22005 * navigator.product -> 'ReactNative' 22006 * nativescript 22007 * navigator.product -> 'NativeScript' or 'NS' 22008 */ 22009function isStandardBrowserEnv() { 22010 if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' || 22011 navigator.product === 'NativeScript' || 22012 navigator.product === 'NS')) { 22013 return false; 22014 } 22015 return ( 22016 typeof window !== 'undefined' && 22017 typeof document !== 'undefined' 22018 ); 22019} 22020 22021/** 22022 * Iterate over an Array or an Object invoking a function for each item. 22023 * 22024 * If `obj` is an Array callback will be called passing 22025 * the value, index, and complete array for each item. 22026 * 22027 * If 'obj' is an Object callback will be called passing 22028 * the value, key, and complete object for each property. 22029 * 22030 * @param {Object|Array} obj The object to iterate 22031 * @param {Function} fn The callback to invoke for each item 22032 */ 22033function forEach(obj, fn) { 22034 // Don't bother if no value provided 22035 if (obj === null || typeof obj === 'undefined') { 22036 return; 22037 } 22038 22039 // Force an array if not already something iterable 22040 if (typeof obj !== 'object') { 22041 /*eslint no-param-reassign:0*/ 22042 obj = [obj]; 22043 } 22044 22045 if (isArray(obj)) { 22046 // Iterate over array values 22047 for (var i = 0, l = obj.length; i < l; i++) { 22048 fn.call(null, obj[i], i, obj); 22049 } 22050 } else { 22051 // Iterate over object keys 22052 for (var key in obj) { 22053 if (Object.prototype.hasOwnProperty.call(obj, key)) { 22054 fn.call(null, obj[key], key, obj); 22055 } 22056 } 22057 } 22058} 22059 22060/** 22061 * Accepts varargs expecting each argument to be an object, then 22062 * immutably merges the properties of each object and returns result. 22063 * 22064 * When multiple objects contain the same key the later object in 22065 * the arguments list will take precedence. 22066 * 22067 * Example: 22068 * 22069 * ```js 22070 * var result = merge({foo: 123}, {foo: 456}); 22071 * console.log(result.foo); // outputs 456 22072 * ``` 22073 * 22074 * @param {Object} obj1 Object to merge 22075 * @returns {Object} Result of all merge properties 22076 */ 22077function merge(/* obj1, obj2, obj3, ... */) { 22078 var result = {}; 22079 function assignValue(val, key) { 22080 if (isPlainObject(result[key]) && isPlainObject(val)) { 22081 result[key] = merge(result[key], val); 22082 } else if (isPlainObject(val)) { 22083 result[key] = merge({}, val); 22084 } else if (isArray(val)) { 22085 result[key] = val.slice(); 22086 } else { 22087 result[key] = val; 22088 } 22089 } 22090 22091 for (var i = 0, l = arguments.length; i < l; i++) { 22092 forEach(arguments[i], assignValue); 22093 } 22094 return result; 22095} 22096 22097/** 22098 * Extends object a by mutably adding to it the properties of object b. 22099 * 22100 * @param {Object} a The object to be extended 22101 * @param {Object} b The object to copy properties from 22102 * @param {Object} thisArg The object to bind function to 22103 * @return {Object} The resulting value of object a 22104 */ 22105function extend(a, b, thisArg) { 22106 forEach(b, function assignValue(val, key) { 22107 if (thisArg && typeof val === 'function') { 22108 a[key] = bind(val, thisArg); 22109 } else { 22110 a[key] = val; 22111 } 22112 }); 22113 return a; 22114} 22115 22116/** 22117 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM) 22118 * 22119 * @param {string} content with BOM 22120 * @return {string} content value without BOM 22121 */ 22122function stripBOM(content) { 22123 if (content.charCodeAt(0) === 0xFEFF) { 22124 content = content.slice(1); 22125 } 22126 return content; 22127} 22128 22129/** 22130 * Inherit the prototype methods from one constructor into another 22131 * @param {function} constructor 22132 * @param {function} superConstructor 22133 * @param {object} [props] 22134 * @param {object} [descriptors] 22135 */ 22136 22137function inherits(constructor, superConstructor, props, descriptors) { 22138 constructor.prototype = Object.create(superConstructor.prototype, descriptors); 22139 constructor.prototype.constructor = constructor; 22140 props && Object.assign(constructor.prototype, props); 22141} 22142 22143/** 22144 * Resolve object with deep prototype chain to a flat object 22145 * @param {Object} sourceObj source object 22146 * @param {Object} [destObj] 22147 * @param {Function} [filter] 22148 * @returns {Object} 22149 */ 22150 22151function toFlatObject(sourceObj, destObj, filter) { 22152 var props; 22153 var i; 22154 var prop; 22155 var merged = {}; 22156 22157 destObj = destObj || {}; 22158 22159 do { 22160 props = Object.getOwnPropertyNames(sourceObj); 22161 i = props.length; 22162 while (i-- > 0) { 22163 prop = props[i]; 22164 if (!merged[prop]) { 22165 destObj[prop] = sourceObj[prop]; 22166 merged[prop] = true; 22167 } 22168 } 22169 sourceObj = Object.getPrototypeOf(sourceObj); 22170 } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype); 22171 22172 return destObj; 22173} 22174 22175/* 22176 * determines whether a string ends with the characters of a specified string 22177 * @param {String} str 22178 * @param {String} searchString 22179 * @param {Number} [position= 0] 22180 * @returns {boolean} 22181 */ 22182function endsWith(str, searchString, position) { 22183 str = String(str); 22184 if (position === undefined || position > str.length) { 22185 position = str.length; 22186 } 22187 position -= searchString.length; 22188 var lastIndex = str.indexOf(searchString, position); 22189 return lastIndex !== -1 && lastIndex === position; 22190} 22191 22192 22193/** 22194 * Returns new array from array like object 22195 * @param {*} [thing] 22196 * @returns {Array} 22197 */ 22198function toArray(thing) { 22199 if (!thing) return null; 22200 var i = thing.length; 22201 if (isUndefined(i)) return null; 22202 var arr = new Array(i); 22203 while (i-- > 0) { 22204 arr[i] = thing[i]; 22205 } 22206 return arr; 22207} 22208 22209// eslint-disable-next-line func-names 22210var isTypedArray = (function(TypedArray) { 22211 // eslint-disable-next-line func-names 22212 return function(thing) { 22213 return TypedArray && thing instanceof TypedArray; 22214 }; 22215})(typeof Uint8Array !== 'undefined' && Object.getPrototypeOf(Uint8Array)); 22216 22217module.exports = { 22218 isArray: isArray, 22219 isArrayBuffer: isArrayBuffer, 22220 isBuffer: isBuffer, 22221 isFormData: isFormData, 22222 isArrayBufferView: isArrayBufferView, 22223 isString: isString, 22224 isNumber: isNumber, 22225 isObject: isObject, 22226 isPlainObject: isPlainObject, 22227 isUndefined: isUndefined, 22228 isDate: isDate, 22229 isFile: isFile, 22230 isBlob: isBlob, 22231 isFunction: isFunction, 22232 isStream: isStream, 22233 isURLSearchParams: isURLSearchParams, 22234 isStandardBrowserEnv: isStandardBrowserEnv, 22235 forEach: forEach, 22236 merge: merge, 22237 extend: extend, 22238 trim: trim, 22239 stripBOM: stripBOM, 22240 inherits: inherits, 22241 toFlatObject: toFlatObject, 22242 kindOf: kindOf, 22243 kindOfTest: kindOfTest, 22244 endsWith: endsWith, 22245 toArray: toArray, 22246 isTypedArray: isTypedArray, 22247 isFileList: isFileList 22248}; 22249 22250 22251/***/ }), 22252 22253/***/ "./node_modules/babel-loader/lib/index.js??clonedRuleSet-5.use[0]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=script&lang=js": 22254/*!**********************************************************************************************************************************************************************************************************!*\ 22255 !*** ./node_modules/babel-loader/lib/index.js??clonedRuleSet-5.use[0]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=script&lang=js ***! 22256 \**********************************************************************************************************************************************************************************************************/ 22257/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 22258 22259"use strict"; 22260__webpack_require__.r(__webpack_exports__); 22261/* harmony import */ var D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./node_modules/@babel/runtime/helpers/esm/regeneratorRuntime.js */ "./node_modules/@babel/runtime/helpers/esm/regeneratorRuntime.js"); 22262/* harmony import */ var D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js */ "./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js"); 22263/* harmony import */ var inputmask__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! inputmask */ "./node_modules/inputmask/dist/inputmask.js"); 22264/* harmony import */ var inputmask__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(inputmask__WEBPACK_IMPORTED_MODULE_2__); 22265/* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! axios */ "./node_modules/axios/index.js"); 22266/* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(axios__WEBPACK_IMPORTED_MODULE_3__); 22267/* harmony import */ var js_cookie__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! js-cookie */ "./node_modules/js-cookie/src/js.cookie.js"); 22268/* harmony import */ var js_cookie__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(js_cookie__WEBPACK_IMPORTED_MODULE_4__); 22269/* harmony import */ var _vuelidate_core__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @vuelidate/core */ "./node_modules/@vuelidate/core/dist/index.esm.js"); 22270/* harmony import */ var _vuelidate_validators__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @vuelidate/validators */ "./node_modules/@vuelidate/validators/dist/index.esm.js"); 22271/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.esm-bundler.js"); 22272 22273 22274 22275 22276 22277 22278 22279 22280/* harmony default export */ __webpack_exports__["default"] = ((0,vue__WEBPACK_IMPORTED_MODULE_6__.defineComponent)({ 22281 setup: function setup() { 22282 return { 22283 v$: (0,_vuelidate_core__WEBPACK_IMPORTED_MODULE_5__["default"])() 22284 }; 22285 }, 22286 data: function data() { 22287 return { 22288 re_token: null, 22289 entered: (0,vue__WEBPACK_IMPORTED_MODULE_6__.reactive)([]), 22290 enteredCode: (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(''), 22291 phone: (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(''), 22292 email: (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(''), 22293 pass: (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(''), 22294 showPassword: (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(false), 22295 showPhone: (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(true), 22296 timer: (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(0), 22297 codeSended: (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(false), 22298 formData: (0,vue__WEBPACK_IMPORTED_MODULE_6__.reactive)({}), 22299 phoneValid: (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(false) 22300 }; 22301 }, 22302 mounted: function mounted() { 22303 var $phone = this.$refs.phone; 22304 var im = new (inputmask__WEBPACK_IMPORTED_MODULE_2___default())("(999) 999-99-99"); 22305 im.mask($phone); 22306 var $c = js_cookie__WEBPACK_IMPORTED_MODULE_4___default().get('_code_sended'); 22307 if ($c) { 22308 this.codeSended = (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(true); 22309 var $date = new Date(); 22310 var $ended = ($c - $date.getTime()) / 1000; 22311 this.startTimer(parseInt($ended)); 22312 } 22313 for (var $i = 0; $i < 4; $i++) { 22314 this.entered[$i] = ''; 22315 } 22316 grecaptcha.ready(function () { 22317 grecaptcha.execute('6LfGVzglAAAAAPkiPix-UqRdxVnGTSnC4fYpUz3f', { 22318 action: 'subscribe' 22319 }).then(function (token) { 22320 $('#loginFrm').find('input[name="token"]').val(token); 22321 }); 22322 }); 22323 setInterval(function () { 22324 grecaptcha.ready(function () { 22325 grecaptcha.execute('6LfGVzglAAAAAPkiPix-UqRdxVnGTSnC4fYpUz3f', { 22326 action: 'subscribe' 22327 }).then(function (token) { 22328 $('#loginFrm').find('input[name="token"]').val(token); 22329 }); 22330 }); 22331 }, 90000); 22332 }, 22333 watch: { 22334 entered: { 22335 handler: function handler(val, oldVal) { 22336 this.enteredCode = (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(val.join('')); 22337 }, 22338 deep: true 22339 }, 22340 enteredCode: function enteredCode(newVal, oldVal) { 22341 if (newVal.length == 4) { 22342 this.validCode(); 22343 } 22344 } 22345 }, 22346 methods: { 22347 onPastePhone: function onPastePhone(e) { 22348 var clipped = e.clipboardData.getData('text'); 22349 this.phone = clipped; 22350 e.target.blur(); 22351 return false; 22352 }, 22353 clearCode: function clearCode(e, index) { 22354 this.entered[index] = ''; 22355 }, 22356 codeChange: function codeChange(e, index) { 22357 var $next = this.$refs['code-' + (index + 1)]; 22358 var $val = parseInt(e.target.value); 22359 if (isNaN($val)) { 22360 e.preventDefault(); 22361 return false; 22362 } 22363 if ($next && $next[0] && !this.codeChecked) $next[0].focus(); 22364 }, 22365 keyDown: function keyDown(e) { 22366 var $char = e.which ? e.which : e.keyCode; 22367 if ($char > 31 && ($char < 48 || $char > 57)) e.preventDefault(); 22368 }, 22369 hidePhone: function hidePhone($val) { 22370 this.showPhone = (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(!$val); 22371 }, 22372 countDownTimer: function countDownTimer() { 22373 var _this = this; 22374 if (this.timer > 0) { 22375 setTimeout(function () { 22376 _this.timer -= 1; 22377 _this.countDownTimer(); 22378 }, 1000); 22379 } else js_cookie__WEBPACK_IMPORTED_MODULE_4___default().remove('_code_sended'); 22380 }, 22381 startTimer: function startTimer($val) { 22382 this.timer = (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)($val); 22383 this.countDownTimer(); 22384 }, 22385 setCookie: function setCookie() { 22386 var $date = new Date(); 22387 var $now = $date.getTime(); 22388 var $ended = $date.setTime($now + 30 * 1000); 22389 var $expires = "; expires=" + $date.toGMTString(); 22390 var $maxAgeSegment = "; max-age=30"; 22391 document.cookie = encodeURI('_code_sended') + "=" + encodeURI($ended) + $expires + $maxAgeSegment; 22392 }, 22393 /*****************************************************/validCode: function validCode() { 22394 var _this2 = this; 22395 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_1__["default"])( /*#__PURE__*/(0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().mark(function _callee() { 22396 var response; 22397 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().wrap(function _callee$(_context) { 22398 while (1) { 22399 switch (_context.prev = _context.next) { 22400 case 0: 22401 showWaiter(); 22402 _context.prev = 1; 22403 _context.next = 4; 22404 return _this2.postValidCode(); 22405 case 4: 22406 response = _context.sent; 22407 _context.next = 11; 22408 break; 22409 case 7: 22410 _context.prev = 7; 22411 _context.t0 = _context["catch"](1); 22412 waiting_close(); 22413 showError(_context.t0); 22414 case 11: 22415 _context.prev = 11; 22416 if (!response.data.success) { 22417 _context.next = 19; 22418 break; 22419 } 22420 waiting_close(); 22421 _this2.phoneValid = (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(true); 22422 _context.next = 17; 22423 return _this2.submitLogin(); 22424 case 17: 22425 _context.next = 22; 22426 break; 22427 case 19: 22428 waiting_close(); 22429 showError('ÐевеÑнÑй код подÑвеÑждениÑ'); 22430 return _context.abrupt("return", false); 22431 case 22: 22432 _this2.codeChecked = (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(true); 22433 return _context.finish(11); 22434 case 24: 22435 case "end": 22436 return _context.stop(); 22437 } 22438 } 22439 }, _callee, null, [[1, 7, 11, 24]]); 22440 }))(); 22441 }, 22442 postValidCode: function postValidCode() { 22443 var _this3 = this; 22444 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_1__["default"])( /*#__PURE__*/(0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().mark(function _callee2() { 22445 var $formData; 22446 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().wrap(function _callee2$(_context2) { 22447 while (1) { 22448 switch (_context2.prev = _context2.next) { 22449 case 0: 22450 $formData = { 22451 'code': _this3.enteredCode, 22452 _token: _this3.token, 22453 're_token': _this3.re_token 22454 }; 22455 _context2.next = 3; 22456 return axios__WEBPACK_IMPORTED_MODULE_3___default().post("/cabinet/phone/code/valid", $formData); 22457 case 3: 22458 return _context2.abrupt("return", _context2.sent); 22459 case 4: 22460 case "end": 22461 return _context2.stop(); 22462 } 22463 } 22464 }, _callee2); 22465 }))(); 22466 }, 22467 sendCode: function sendCode() { 22468 var _this4 = this; 22469 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_1__["default"])( /*#__PURE__*/(0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().mark(function _callee3() { 22470 var response; 22471 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().wrap(function _callee3$(_context3) { 22472 while (1) { 22473 switch (_context3.prev = _context3.next) { 22474 case 0: 22475 showWaiter(); 22476 _context3.prev = 1; 22477 _context3.next = 4; 22478 return _this4.postCode(); 22479 case 4: 22480 response = _context3.sent; 22481 _context3.next = 11; 22482 break; 22483 case 7: 22484 _context3.prev = 7; 22485 _context3.t0 = _context3["catch"](1); 22486 waiting_close(); 22487 showError(_context3.t0); 22488 case 11: 22489 _context3.prev = 11; 22490 if (response.data.success) { 22491 waiting_close(); 22492 //showMessage('Ðод оÑпÑавлен на ÑказаннÑй Ð½Ð¾Ð¼ÐµÑ ÑелеÑона'); 22493 _this4.codeSended = (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(true); 22494 _this4.clearCode(); 22495 _this4.phoneValid = (0,vue__WEBPACK_IMPORTED_MODULE_6__.ref)(false); 22496 _this4.setCookie(); 22497 _this4.startTimer(30); 22498 } else { 22499 waiting_close(); 22500 showError('ÐÑибка пÑи оÑпÑавке ÑообÑениÑ. ÐопÑобÑйÑе позже'); 22501 } 22502 return _context3.finish(11); 22503 case 14: 22504 case "end": 22505 return _context3.stop(); 22506 } 22507 } 22508 }, _callee3, null, [[1, 7, 11, 14]]); 22509 }))(); 22510 }, 22511 postCode: function postCode() { 22512 var _this5 = this; 22513 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_1__["default"])( /*#__PURE__*/(0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().mark(function _callee4() { 22514 var re_token, $formData; 22515 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().wrap(function _callee4$(_context4) { 22516 while (1) { 22517 switch (_context4.prev = _context4.next) { 22518 case 0: 22519 re_token = $('#loginFrm').find('input[name="token"]').val(); 22520 $formData = { 22521 'phone': _this5.phone, 22522 _token: _this5.token, 22523 're_token': re_token 22524 }; 22525 _context4.next = 4; 22526 return axios__WEBPACK_IMPORTED_MODULE_3___default().post("/cabinet/phone/code/send", $formData); 22527 case 4: 22528 return _context4.abrupt("return", _context4.sent); 22529 case 5: 22530 case "end": 22531 return _context4.stop(); 22532 } 22533 } 22534 }, _callee4); 22535 }))(); 22536 }, 22537 submitLogin: function submitLogin() { 22538 var _this6 = this; 22539 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_1__["default"])( /*#__PURE__*/(0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().mark(function _callee5() { 22540 var response, $way; 22541 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().wrap(function _callee5$(_context5) { 22542 while (1) { 22543 switch (_context5.prev = _context5.next) { 22544 case 0: 22545 showWaiter(); 22546 _context5.prev = 1; 22547 _context5.next = 4; 22548 return _this6.postLogin(); 22549 case 4: 22550 response = _context5.sent; 22551 _context5.next = 11; 22552 break; 22553 case 7: 22554 _context5.prev = 7; 22555 _context5.t0 = _context5["catch"](1); 22556 waiting_close(); 22557 showError(_context5.t0); 22558 case 11: 22559 _context5.prev = 11; 22560 waiting_close(); 22561 $way = window.sessionStorage.getItem('enterTo'); 22562 $way = !$way || $way.length <= 0 || $way == 'undefined' ? '/cabinet' : '/' + $way; 22563 _this6.formData.response = response.data; 22564 if (response.data.success) { 22565 // ФоÑма Ð²Ñ Ð¾Ð´Ð° ÑмонÑиÑована оÑделÑнÑм пÑиложением, без store â 22566 // клÑÑи коÑÐ·Ð¸Ð½Ñ ÑиÑÑÑÑÑÑ Ð½Ð°Ð¿ÑÑмÑÑ. Ðез ÑÑого гаÑд `inited` 22567 // в basket_store пеÑÐµÐ¶Ð¸Ð²Ð°ÐµÑ location.replace и на новой 22568 // ÑÑÑаниÑе показÑваеÑÑÑ Ð¿ÑежнÑÑ (догиннаÑ) коÑзина. 22569 // `enterTo` пÑоÑиÑан вÑÑе и здеÑÑ Ñже не нÑжен. 22570 ['basketLines', 'basketDelivery', 'basketPayment', 'goodsInActions', 'basketBuyer', 'buyerSpecialties', 'inited'].forEach(function (key) { 22571 window.sessionStorage.removeItem(key); 22572 }); 22573 setTimeout(function () { 22574 window.location.replace($way); 22575 }, 200); 22576 } else { 22577 waiting_close(); 22578 showError(response.data.message); 22579 } 22580 return _context5.finish(11); 22581 case 18: 22582 case "end": 22583 return _context5.stop(); 22584 } 22585 } 22586 }, _callee5, null, [[1, 7, 11, 18]]); 22587 }))(); 22588 }, 22589 postLogin: function postLogin() { 22590 var _this7 = this; 22591 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_1__["default"])( /*#__PURE__*/(0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().mark(function _callee6() { 22592 var $form, $formData; 22593 return (0,D_breket_loc_breket_test_loc_node_modules_babel_runtime_helpers_esm_regeneratorRuntime_js__WEBPACK_IMPORTED_MODULE_0__["default"])().wrap(function _callee6$(_context6) { 22594 while (1) { 22595 switch (_context6.prev = _context6.next) { 22596 case 0: 22597 $form = _this7.$refs.form; 22598 $formData = new FormData($form); 22599 $formData.append("method", _this7.method); 22600 $formData.append("_token", _this7.token); 22601 _this7.formData = { 22602 'phone': _this7.phone, 22603 'enteredCode': _this7.enteredCode, 22604 'storedCode': '', 22605 'email': _this7.email, 22606 'password': _this7.pass, 22607 '_token': _this7.token 22608 }; 22609 //console.log(this.formData); 22610 _context6.next = 7; 22611 return axios__WEBPACK_IMPORTED_MODULE_3___default().post("/auth/login", $formData); 22612 case 7: 22613 return _context6.abrupt("return", _context6.sent); 22614 case 8: 22615 case "end": 22616 return _context6.stop(); 22617 } 22618 } 22619 }, _callee6); 22620 }))(); 22621 }, 22622 str_random: function str_random() { 22623 return Math.random().toString(36).substring(2, 6) + Math.random().toString(36).substring(2, 6); 22624 } 22625 }, 22626 validations: { 22627 phone: { 22628 required: _vuelidate_validators__WEBPACK_IMPORTED_MODULE_7__.required, 22629 valid: function valid(val) { 22630 var $clear = val.replace(/[^\d]/g, ''); 22631 return $clear.length == 10; 22632 } 22633 }, 22634 email: { 22635 required: _vuelidate_validators__WEBPACK_IMPORTED_MODULE_7__.required, 22636 validFormat: function validFormat(val) { 22637 return /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/.test(val); 22638 } 22639 }, 22640 enteredCode: { 22641 required: _vuelidate_validators__WEBPACK_IMPORTED_MODULE_7__.required, 22642 minLength: (0,_vuelidate_validators__WEBPACK_IMPORTED_MODULE_7__.minLength)(4), 22643 number: function number(val) { 22644 return /^[0-9]*$/i.test(val); 22645 } 22646 }, 22647 pass: { 22648 required: _vuelidate_validators__WEBPACK_IMPORTED_MODULE_7__.required, 22649 minLength: (0,_vuelidate_validators__WEBPACK_IMPORTED_MODULE_7__.minLength)(4) 22650 } 22651 }, 22652 computed: { 22653 token: function token() { 22654 var $token = document.head.querySelector('meta[name="csrf-token"]'); 22655 return $token.content; 22656 }, 22657 method: function method() { 22658 if (this.codeSended && this.phone.length > 0) return 'phone'; 22659 if (!this.codeSended && this.email.length > 0) return 'email'; 22660 }, 22661 ready: function ready() { 22662 var res = false; 22663 if (this.showPhone && this.codeSended && !this.v$.phone.$error && this.enteredCode.length && !this.v$.enteredCode.$error) res = true; 22664 if (!this.showPhone && !this.codeSended && !this.v$.email.$error && this.pass.length) res = true; 22665 return res; 22666 } 22667 } 22668})); 22669 22670/***/ }), 22671 22672/***/ "./node_modules/babel-loader/lib/index.js??clonedRuleSet-5.use[0]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=template&id=8fcbc800&scoped=true": 22673/*!**************************************************************************************************************************************************************************************************************************************************************************************************!*\ 22674 !*** ./node_modules/babel-loader/lib/index.js??clonedRuleSet-5.use[0]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=template&id=8fcbc800&scoped=true ***! 22675 \**************************************************************************************************************************************************************************************************************************************************************************************************/ 22676/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 22677 22678"use strict"; 22679__webpack_require__.r(__webpack_exports__); 22680/* harmony export */ __webpack_require__.d(__webpack_exports__, { 22681/* harmony export */ "render": function() { return /* binding */ render; } 22682/* harmony export */ }); 22683/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.esm-bundler.js"); 22684 22685var _withScopeId = function _withScopeId(n) { 22686 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.pushScopeId)("data-v-8fcbc800"), n = n(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.popScopeId)(), n; 22687}; 22688var _hoisted_1 = { 22689 "class": "card-body" 22690}; 22691var _hoisted_2 = /*#__PURE__*/_withScopeId(function () { 22692 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("h4", { 22693 "class": "card-title h5" 22694 }, "ÐаÑегиÑÑÑиÑованнÑй клиенÑ", -1 /* HOISTED */); 22695}); 22696var _hoisted_3 = { 22697 method: "post", 22698 name: "loginFrm", 22699 id: "loginFrm", 22700 action: "", 22701 ref: "form" 22702}; 22703var _hoisted_4 = { 22704 "class": "login-type" 22705}; 22706var _hoisted_5 = /*#__PURE__*/_withScopeId(function () { 22707 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", { 22708 type: "hidden", 22709 name: "token" 22710 }, null, -1 /* HOISTED */); 22711}); 22712var _hoisted_6 = { 22713 "class": "login-type__item row", 22714 id: "login-type-phone", 22715 ref: "login-phone-row" 22716}; 22717var _hoisted_7 = { 22718 "class": "form-group col-md-6" 22719}; 22720var _hoisted_8 = /*#__PURE__*/_withScopeId(function () { 22721 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", { 22722 "class": "control-label", 22723 "for": "input-phone" 22724 }, "ÐÐ¾Ð¼ÐµÑ ÑелеÑона", -1 /* HOISTED */); 22725}); 22726var _hoisted_9 = { 22727 "class": "input-group" 22728}; 22729var _hoisted_10 = /*#__PURE__*/_withScopeId(function () { 22730 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { 22731 "class": "input-group-prepend" 22732 }, [/*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { 22733 "class": "input-group-text" 22734 }, "+7")], -1 /* HOISTED */); 22735}); 22736var _hoisted_11 = ["autocomplete"]; 22737var _hoisted_12 = { 22738 key: 0, 22739 "class": "error" 22740}; 22741var _hoisted_13 = { 22742 "class": "form-group col-md-6" 22743}; 22744var _hoisted_14 = { 22745 key: 0 22746}; 22747var _hoisted_15 = /*#__PURE__*/_withScopeId(function () { 22748 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", { 22749 "class": "control-label", 22750 "for": "input-code" 22751 }, "Ðод из СÐС", -1 /* HOISTED */); 22752}); 22753var _hoisted_16 = { 22754 id: "input-code" 22755}; 22756var _hoisted_17 = ["name", "onUpdate:modelValue", "id", "disabled", "onInput", "onFocus"]; 22757var _hoisted_18 = /*#__PURE__*/_withScopeId(function () { 22758 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", { 22759 "class": "control-label", 22760 style: { 22761 "display": "block" 22762 } 22763 }, " ", -1 /* HOISTED */); 22764}); 22765var _hoisted_19 = /*#__PURE__*/_withScopeId(function () { 22766 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { 22767 "class": "fa fa-check", 22768 style: { 22769 "color": "green", 22770 "font-size": "25px" 22771 } 22772 }, null, -1 /* HOISTED */); 22773}); 22774var _hoisted_20 = { 22775 key: 1 22776}; 22777var _hoisted_21 = /*#__PURE__*/_withScopeId(function () { 22778 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", { 22779 "class": "control-label" 22780 }, " ", -1 /* HOISTED */); 22781}); 22782var _hoisted_22 = { 22783 key: 0, 22784 "class": "login-type__resend" 22785}; 22786var _hoisted_23 = ["disabled"]; 22787var _hoisted_24 = { 22788 key: 0, 22789 "class": "login-type__informer col-md-12 mb-2 text-danger" 22790}; 22791var _hoisted_25 = { 22792 key: 1, 22793 "class": "login-type__resend col-md-12 mb-3" 22794}; 22795var _hoisted_26 = { 22796 "class": "login-type__item row", 22797 id: "login-type-email" 22798}; 22799var _hoisted_27 = { 22800 "class": "col-md-6 form-group" 22801}; 22802var _hoisted_28 = /*#__PURE__*/_withScopeId(function () { 22803 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", { 22804 "class": "control-label", 22805 "for": "input-email" 22806 }, "E-Mail", -1 /* HOISTED */); 22807}); 22808var _hoisted_29 = ["autocomplete"]; 22809var _hoisted_30 = { 22810 key: 0, 22811 "class": "error" 22812}; 22813var _hoisted_31 = { 22814 "class": "col-md-6 form-group" 22815}; 22816var _hoisted_32 = /*#__PURE__*/_withScopeId(function () { 22817 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", { 22818 "class": "control-label", 22819 "for": "input-password" 22820 }, "ÐаÑолÑ", -1 /* HOISTED */); 22821}); 22822var _hoisted_33 = { 22823 key: 2, 22824 "class": "error" 22825}; 22826var _hoisted_34 = { 22827 "class": "mb-3" 22828}; 22829var _hoisted_35 = { 22830 "class": "row" 22831}; 22832var _hoisted_36 = { 22833 "class": "col-sm-6 mb-2 mb-sm-0" 22834}; 22835var _hoisted_37 = ["disabled"]; 22836var _hoisted_38 = /*#__PURE__*/_withScopeId(function () { 22837 return /*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { 22838 "class": "col-sm-6 text-right" 22839 }, [/*#__PURE__*/(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", { 22840 href: "/cabinet/register", 22841 "class": "btn btn-link register" 22842 }, "РегиÑÑÑаÑиÑ")], -1 /* HOISTED */); 22843}); 22844 22845function render(_ctx, _cache, $props, $setup, $data, $options) { 22846 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", _hoisted_1, [_hoisted_2, (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("form", _hoisted_3, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_4, [_hoisted_5, (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_6, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_7, [_hoisted_8, (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_9, [_hoisted_10, (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)(" type=\"search\" ÑÑÐ¾Ð¸Ñ Ð¾Ñознанно. Так еÑÑÑ Ð²ÐµÑоÑÑноÑÑÑ Ð¸Ð·Ð±Ð°Ð²Ð¸ÑÑÑÑ Ð¾Ñ Ð°Ð²ÑÐ¾Ð·Ð°Ð¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ "), (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", { 22847 type: "search", 22848 name: "login_phone", 22849 "onUpdate:modelValue": _cache[0] || (_cache[0] = function ($event) { 22850 return _ctx.phone = $event; 22851 }), 22852 onKeydown: _cache[1] || (_cache[1] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(function () {}, ["ctrl", "prevent", "stop"])), 22853 onPaste: _cache[2] || (_cache[2] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(function ($event) { 22854 return _ctx.onPastePhone($event); 22855 }, ["prevent"])), 22856 onBlur: _cache[3] || (_cache[3] = function ($event) { 22857 return _ctx.v$.phone.$touch(); 22858 }), 22859 onFocus: _cache[4] || (_cache[4] = function ($event) { 22860 return _ctx.v$.phone.$touch(); 22861 }), 22862 ref: "phone", 22863 placeholder: "(___) ___-__-__", 22864 id: "input-phone", 22865 "class": "form-control", 22866 autocomplete: 'autocomplete_off_hack_' + _ctx.str_random() 22867 }, null, 40 /* PROPS, HYDRATE_EVENTS */, _hoisted_11), [[vue__WEBPACK_IMPORTED_MODULE_0__.vModelText, _ctx.phone]]), _ctx.v$.phone.$error ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", _hoisted_12, [_ctx.v$.phone.$invalid ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { 22868 key: 0 22869 }, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" УкажиÑе коÑÑекÑнÑй Ð½Ð¾Ð¼ÐµÑ ÑелеÑона ")], 64 /* STABLE_FRAGMENT */)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true)])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true)])]), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_13, [_ctx.codeSended && !_ctx.phoneValid ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", _hoisted_14, [_hoisted_15, (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("section", _hoisted_16, [((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(true), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(_ctx.entered, function (val, index) { 22870 return (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("input", { 22871 type: "search", 22872 name: 'phone_code_' + index, 22873 "onUpdate:modelValue": function onUpdateModelValue($event) { 22874 return _ctx.entered[index] = $event; 22875 }, 22876 key: 'code-' + index, 22877 id: 'code-' + index, 22878 ref_for: true, 22879 ref: 'code-' + index, 22880 "class": "form-control code", 22881 disabled: index > 0 && _ctx.entered[index - 1] <= '', 22882 onInput: function onInput($event) { 22883 return _ctx.codeChange($event, index); 22884 }, 22885 placeholder: "_", 22886 onKeypress: _cache[5] || (_cache[5] = function ($event) { 22887 return _ctx.keyDown($event); 22888 }), 22889 onFocus: function onFocus($event) { 22890 return _ctx.clearCode($event, index); 22891 }, 22892 autocomplete: "off" 22893 }, null, 40 /* PROPS, HYDRATE_EVENTS */, _hoisted_17)), [[vue__WEBPACK_IMPORTED_MODULE_0__.vModelText, _ctx.entered[index]]]); 22894 }), 128 /* KEYED_FRAGMENT */))])])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true), (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", null, [_hoisted_18, _hoisted_19, (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", { 22895 type: "hidden", 22896 name: "login_code", 22897 "onUpdate:modelValue": _cache[6] || (_cache[6] = function ($event) { 22898 return _ctx.enteredCode = $event; 22899 }) 22900 }, null, 512 /* NEED_PATCH */), [[vue__WEBPACK_IMPORTED_MODULE_0__.vModelText, _ctx.enteredCode]])], 512 /* NEED_PATCH */), [[vue__WEBPACK_IMPORTED_MODULE_0__.vShow, _ctx.codeSended && _ctx.phoneValid]]), !_ctx.codeSended && !_ctx.phoneValid ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", _hoisted_20, [_hoisted_21, _ctx.timer <= 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", _hoisted_22, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", { 22901 "class": "btn btn-default", 22902 type: "button", 22903 onClick: _cache[7] || (_cache[7] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(function () { 22904 return _ctx.sendCode && _ctx.sendCode.apply(_ctx, arguments); 22905 }, ["prevent"])), 22906 disabled: _ctx.v$.phone.$invalid 22907 }, "ÐолÑÑиÑÑ SMS код", 8 /* PROPS */, _hoisted_23)])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true)])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true)]), _ctx.timer > 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", _hoisted_24, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" ÐолÑÑиÑÑ ÐºÐ¾Ð´ повÑоÑно можно ÑеÑез "), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(_ctx.timer) + " ÑекÑнд", 1 /* TEXT */)])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true), _ctx.timer <= 0 && _ctx.codeSended ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", _hoisted_25, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", { 22908 href: "javascript:;", 22909 onClick: _cache[8] || (_cache[8] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(function () { 22910 return _ctx.sendCode && _ctx.sendCode.apply(_ctx, arguments); 22911 }, ["prevent"])) 22912 }, "ÐолÑÑиÑÑ ÐºÐ¾Ð´ повÑоÑно")])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true)], 512 /* NEED_PATCH */), [[vue__WEBPACK_IMPORTED_MODULE_0__.vShow, _ctx.showPhone]]), (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_26, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_27, [_hoisted_28, (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)(" type=\"search\" ÑÑÐ¾Ð¸Ñ Ð¾Ñознанно. Так еÑÑÑ Ð²ÐµÑоÑÑноÑÑÑ Ð¸Ð·Ð±Ð°Ð²Ð¸ÑÑÑÑ Ð¾Ñ Ð°Ð²ÑÐ¾Ð·Ð°Ð¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ "), (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", { 22913 type: "search", 22914 name: "login_email", 22915 placeholder: "E-Mail", 22916 id: "input-email", 22917 "class": "form-control", 22918 "onUpdate:modelValue": _cache[9] || (_cache[9] = function ($event) { 22919 return _ctx.email = $event; 22920 }), 22921 onBlur: _cache[10] || (_cache[10] = function ($event) { 22922 return _ctx.v$.email.$touch(); 22923 }), 22924 onFocus: _cache[11] || (_cache[11] = function ($event) { 22925 return _ctx.v$.email.$touch(); 22926 }), 22927 autocomplete: 'autocomplete_off_hack_' + _ctx.str_random() 22928 }, null, 40 /* PROPS, HYDRATE_EVENTS */, _hoisted_29), [[vue__WEBPACK_IMPORTED_MODULE_0__.vModelText, _ctx.email]]), _ctx.v$.email.$error ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", _hoisted_30, [_ctx.v$.email.$invalid ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { 22929 key: 0 22930 }, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" УкажиÑе коÑÑекÑнÑй Email ")], 64 /* STABLE_FRAGMENT */)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true)])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true)]), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_31, [_hoisted_32, !_ctx.showPassword ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("input", { 22931 key: 0, 22932 type: "password", 22933 name: "login_password", 22934 placeholder: "ÐаÑолÑ", 22935 id: "input-password", 22936 "class": "form-control", 22937 "onUpdate:modelValue": _cache[12] || (_cache[12] = function ($event) { 22938 return _ctx.pass = $event; 22939 }), 22940 onBlur: _cache[13] || (_cache[13] = function ($event) { 22941 return _ctx.v$.pass.$touch(); 22942 }), 22943 autocomplete: "off" 22944 }, null, 544 /* HYDRATE_EVENTS, NEED_PATCH */)), [[vue__WEBPACK_IMPORTED_MODULE_0__.vModelText, _ctx.pass, void 0, { 22945 trim: true 22946 }]]) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true), _ctx.showPassword ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("input", { 22947 key: 1, 22948 type: "search", 22949 name: "login_password", 22950 placeholder: "ÐаÑолÑ", 22951 id: "input-password", 22952 "class": "form-control", 22953 "onUpdate:modelValue": _cache[14] || (_cache[14] = function ($event) { 22954 return _ctx.pass = $event; 22955 }), 22956 onBlur: _cache[15] || (_cache[15] = function ($event) { 22957 return _ctx.v$.pass.$touch(); 22958 }), 22959 autocomplete: "off" 22960 }, null, 544 /* HYDRATE_EVENTS, NEED_PATCH */)), [[vue__WEBPACK_IMPORTED_MODULE_0__.vModelText, _ctx.pass, void 0, { 22961 trim: true 22962 }]]) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", { 22963 "class": (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["form__show-password", { 22964 'form__show-password_active': _ctx.showPassword 22965 }]), 22966 type: "button", 22967 title: "ÐоказаÑÑ Ð¿Ð°ÑолÑ", 22968 onClick: _cache[16] || (_cache[16] = function ($event) { 22969 return _ctx.showPassword = !_ctx.showPassword; 22970 }) 22971 }, null, 2 /* CLASS */), _ctx.v$.pass.$error ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", _hoisted_33, [!_ctx.v$.pass.minLength ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { 22972 key: 0 22973 }, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" ÐаÑÐ¾Ð»Ñ Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ Ð±ÑÑÑ Ð¼ÐµÐ½ÑÑе " + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(_ctx.v$.enteredCode.$params.minLength.min) + " Ñимволов ", 1 /* TEXT */)], 64 /* STABLE_FRAGMENT */)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { 22974 key: 1 22975 }, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" ÐбÑзаÑелÑно Ð´Ð»Ñ Ð·Ð°Ð¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ ")], 64 /* STABLE_FRAGMENT */))])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("v-if", true)])], 512 /* NEED_PATCH */), [[vue__WEBPACK_IMPORTED_MODULE_0__.vShow, !_ctx.showPhone]]), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_34, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", { 22976 "class": "login-type__btn", 22977 type: "button", 22978 onClick: _cache[17] || (_cache[17] = function ($event) { 22979 return _ctx.hidePhone(false); 22980 }) 22981 }, "ÐойÑи по номеÑÑ ÑелеÑона", 512 /* NEED_PATCH */), [[vue__WEBPACK_IMPORTED_MODULE_0__.vShow, !_ctx.showPhone]]), (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", { 22982 "class": "login-type__btn", 22983 type: "button", 22984 onClick: _cache[18] || (_cache[18] = function ($event) { 22985 return _ctx.hidePhone(true); 22986 }) 22987 }, "ÐойÑи по поÑÑе", 512 /* NEED_PATCH */), [[vue__WEBPACK_IMPORTED_MODULE_0__.vShow, _ctx.showPhone]])])]), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("\r\n <div class=\"row\" v-if=\"formData && formData._token\">\r\n {{formData}}\r\n </div>\r\n"), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_35, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _hoisted_36, [(0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", { 22988 type: "submit", 22989 "class": "btn btn-success", 22990 disabled: !_ctx.ready, 22991 onClick: _cache[19] || (_cache[19] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(function () { 22992 return _ctx.submitLogin && _ctx.submitLogin.apply(_ctx, arguments); 22993 }, ["prevent"])) 22994 }, "ÐÐÐТРРÐÐÐÐÐÐТ", 8 /* PROPS */, _hoisted_37)], 512 /* NEED_PATCH */), [[vue__WEBPACK_IMPORTED_MODULE_0__.vShow, !_ctx.showPhone]]), _hoisted_38])], 512 /* NEED_PATCH */)]); 22995} 22996 22997/***/ }), 22998
vendor: 4,183 bytes, lines 22999-23159
22999/***/ "./node_modules/base64-js/index.js": 23000/*!*****************************************!*\ 23001 !*** ./node_modules/base64-js/index.js ***! 23002 \*****************************************/ 23003/***/ (function(__unused_webpack_module, exports) { 23004 23005"use strict"; 23006 23007 23008exports.byteLength = byteLength 23009exports.toByteArray = toByteArray 23010exports.fromByteArray = fromByteArray 23011 23012var lookup = [] 23013var revLookup = [] 23014var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array 23015 23016var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' 23017for (var i = 0, len = code.length; i < len; ++i) { 23018 lookup[i] = code[i] 23019 revLookup[code.charCodeAt(i)] = i 23020} 23021 23022// Support decoding URL-safe base64 strings, as Node.js does. 23023// See: https://en.wikipedia.org/wiki/Base64#URL_applications 23024revLookup['-'.charCodeAt(0)] = 62 23025revLookup['_'.charCodeAt(0)] = 63 23026 23027function getLens (b64) { 23028 var len = b64.length 23029 23030 if (len % 4 > 0) { 23031 throw new Error('Invalid string. Length must be a multiple of 4') 23032 } 23033 23034 // Trim off extra bytes after placeholder bytes are found 23035 // See: https://github.com/beatgammit/base64-js/issues/42 23036 var validLen = b64.indexOf('=') 23037 if (validLen === -1) validLen = len 23038 23039 var placeHoldersLen = validLen === len 23040 ? 0 23041 : 4 - (validLen % 4) 23042 23043 return [validLen, placeHoldersLen] 23044} 23045 23046// base64 is 4/3 + up to two characters of the original data 23047function byteLength (b64) { 23048 var lens = getLens(b64) 23049 var validLen = lens[0] 23050 var placeHoldersLen = lens[1] 23051 return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen 23052} 23053 23054function _byteLength (b64, validLen, placeHoldersLen) { 23055 return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen 23056} 23057 23058function toByteArray (b64) { 23059 var tmp 23060 var lens = getLens(b64) 23061 var validLen = lens[0] 23062 var placeHoldersLen = lens[1] 23063 23064 var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)) 23065 23066 var curByte = 0 23067 23068 // if there are placeholders, only get up to the last complete 4 chars 23069 var len = placeHoldersLen > 0 23070 ? validLen - 4 23071 : validLen 23072 23073 var i 23074 for (i = 0; i < len; i += 4) { 23075 tmp = 23076 (revLookup[b64.charCodeAt(i)] << 18) | 23077 (revLookup[b64.charCodeAt(i + 1)] << 12) | 23078 (revLookup[b64.charCodeAt(i + 2)] << 6) | 23079 revLookup[b64.charCodeAt(i + 3)] 23080 arr[curByte++] = (tmp >> 16) & 0xFF 23081 arr[curByte++] = (tmp >> 8) & 0xFF 23082 arr[curByte++] = tmp & 0xFF 23083 } 23084 23085 if (placeHoldersLen === 2) { 23086 tmp = 23087 (revLookup[b64.charCodeAt(i)] << 2) | 23088 (revLookup[b64.charCodeAt(i + 1)] >> 4) 23089 arr[curByte++] = tmp & 0xFF 23090 } 23091 23092 if (placeHoldersLen === 1) { 23093 tmp = 23094 (revLookup[b64.charCodeAt(i)] << 10) | 23095 (revLookup[b64.charCodeAt(i + 1)] << 4) | 23096 (revLookup[b64.charCodeAt(i + 2)] >> 2) 23097 arr[curByte++] = (tmp >> 8) & 0xFF 23098 arr[curByte++] = tmp & 0xFF 23099 } 23100 23101 return arr 23102} 23103 23104function tripletToBase64 (num) { 23105 return lookup[num >> 18 & 0x3F] + 23106 lookup[num >> 12 & 0x3F] + 23107 lookup[num >> 6 & 0x3F] + 23108 lookup[num & 0x3F] 23109} 23110 23111function encodeChunk (uint8, start, end) { 23112 var tmp 23113 var output = [] 23114 for (var i = start; i < end; i += 3) { 23115 tmp = 23116 ((uint8[i] << 16) & 0xFF0000) + 23117 ((uint8[i + 1] << 8) & 0xFF00) + 23118 (uint8[i + 2] & 0xFF) 23119 output.push(tripletToBase64(tmp)) 23120 } 23121 return output.join('') 23122} 23123 23124function fromByteArray (uint8) { 23125 var tmp 23126 var len = uint8.length 23127 var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes 23128 var parts = [] 23129 var maxChunkLength = 16383 // must be multiple of 3 23130 23131 // go through the array every three bytes, we'll deal with trailing stuff later 23132 for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { 23133 parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))) 23134 } 23135 23136 // pad the end with zeros, but make sure to not forget the extra bytes 23137 if (extraBytes === 1) { 23138 tmp = uint8[len - 1] 23139 parts.push( 23140 lookup[tmp >> 2] + 23141 lookup[(tmp << 4) & 0x3F] + 23142 '==' 23143 ) 23144 } else if (extraBytes === 2) { 23145 tmp = (uint8[len - 2] << 8) + uint8[len - 1] 23146 parts.push( 23147 lookup[tmp >> 10] + 23148 lookup[(tmp >> 4) & 0x3F] + 23149 lookup[(tmp << 2) & 0x3F] + 23150 '=' 23151 ) 23152 } 23153 23154 return parts.join('') 23155} 23156 23157 23158/***/ }), 23159
vendor: 56,663 bytes, lines 23160-25008
23160/***/ "./node_modules/buffer/index.js": 23161/*!**************************************!*\ 23162 !*** ./node_modules/buffer/index.js ***! 23163 \**************************************/ 23164/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 23165 23166"use strict"; 23167/*! 23168 * The buffer module from node.js, for the browser. 23169 * 23170 * @author Feross Aboukhadijeh <https://feross.org> 23171 * @license MIT 23172 */ 23173/* eslint-disable no-proto */ 23174 23175 23176 23177var base64 = __webpack_require__(/*! base64-js */ "./node_modules/base64-js/index.js") 23178var ieee754 = __webpack_require__(/*! ieee754 */ "./node_modules/ieee754/index.js") 23179var customInspectSymbol = 23180 (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation 23181 ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation 23182 : null 23183 23184exports.Buffer = Buffer 23185exports.SlowBuffer = SlowBuffer 23186exports.INSPECT_MAX_BYTES = 50 23187 23188var K_MAX_LENGTH = 0x7fffffff 23189exports.kMaxLength = K_MAX_LENGTH 23190 23191/** 23192 * If `Buffer.TYPED_ARRAY_SUPPORT`: 23193 * === true Use Uint8Array implementation (fastest) 23194 * === false Print warning and recommend using `buffer` v4.x which has an Object 23195 * implementation (most compatible, even IE6) 23196 * 23197 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, 23198 * Opera 11.6+, iOS 4.2+. 23199 * 23200 * We report that the browser does not support typed arrays if the are not subclassable 23201 * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array` 23202 * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support 23203 * for __proto__ and has a buggy typed array implementation. 23204 */ 23205Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport() 23206 23207if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' && 23208 typeof console.error === 'function') { 23209 console.error( 23210 'This browser lacks typed array (Uint8Array) support which is required by ' + 23211 '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.' 23212 ) 23213} 23214 23215function typedArraySupport () { 23216 // Can typed array instances can be augmented? 23217 try { 23218 var arr = new Uint8Array(1) 23219 var proto = { foo: function () { return 42 } } 23220 Object.setPrototypeOf(proto, Uint8Array.prototype) 23221 Object.setPrototypeOf(arr, proto) 23222 return arr.foo() === 42 23223 } catch (e) { 23224 return false 23225 } 23226} 23227 23228Object.defineProperty(Buffer.prototype, 'parent', { 23229 enumerable: true, 23230 get: function () { 23231 if (!Buffer.isBuffer(this)) return undefined 23232 return this.buffer 23233 } 23234}) 23235 23236Object.defineProperty(Buffer.prototype, 'offset', { 23237 enumerable: true, 23238 get: function () { 23239 if (!Buffer.isBuffer(this)) return undefined 23240 return this.byteOffset 23241 } 23242}) 23243 23244function createBuffer (length) { 23245 if (length > K_MAX_LENGTH) { 23246 throw new RangeError('The value "' + length + '" is invalid for option "size"') 23247 } 23248 // Return an augmented `Uint8Array` instance 23249 var buf = new Uint8Array(length) 23250 Object.setPrototypeOf(buf, Buffer.prototype) 23251 return buf 23252} 23253 23254/** 23255 * The Buffer constructor returns instances of `Uint8Array` that have their 23256 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of 23257 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods 23258 * and the `Uint8Array` methods. Square bracket notation works as expected -- it 23259 * returns a single octet. 23260 * 23261 * The `Uint8Array` prototype remains unmodified. 23262 */ 23263 23264function Buffer (arg, encodingOrOffset, length) { 23265 // Common case. 23266 if (typeof arg === 'number') { 23267 if (typeof encodingOrOffset === 'string') { 23268 throw new TypeError( 23269 'The "string" argument must be of type string. Received type number' 23270 ) 23271 } 23272 return allocUnsafe(arg) 23273 } 23274 return from(arg, encodingOrOffset, length) 23275} 23276 23277Buffer.poolSize = 8192 // not used by this implementation 23278 23279function from (value, encodingOrOffset, length) { 23280 if (typeof value === 'string') { 23281 return fromString(value, encodingOrOffset) 23282 } 23283 23284 if (ArrayBuffer.isView(value)) { 23285 return fromArrayView(value) 23286 } 23287 23288 if (value == null) { 23289 throw new TypeError( 23290 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + 23291 'or Array-like Object. Received type ' + (typeof value) 23292 ) 23293 } 23294 23295 if (isInstance(value, ArrayBuffer) || 23296 (value && isInstance(value.buffer, ArrayBuffer))) { 23297 return fromArrayBuffer(value, encodingOrOffset, length) 23298 } 23299 23300 if (typeof SharedArrayBuffer !== 'undefined' && 23301 (isInstance(value, SharedArrayBuffer) || 23302 (value && isInstance(value.buffer, SharedArrayBuffer)))) { 23303 return fromArrayBuffer(value, encodingOrOffset, length) 23304 } 23305 23306 if (typeof value === 'number') { 23307 throw new TypeError( 23308 'The "value" argument must not be of type number. Received type number' 23309 ) 23310 } 23311 23312 var valueOf = value.valueOf && value.valueOf() 23313 if (valueOf != null && valueOf !== value) { 23314 return Buffer.from(valueOf, encodingOrOffset, length) 23315 } 23316 23317 var b = fromObject(value) 23318 if (b) return b 23319 23320 if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null && 23321 typeof value[Symbol.toPrimitive] === 'function') { 23322 return Buffer.from( 23323 value[Symbol.toPrimitive]('string'), encodingOrOffset, length 23324 ) 23325 } 23326 23327 throw new TypeError( 23328 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + 23329 'or Array-like Object. Received type ' + (typeof value) 23330 ) 23331} 23332 23333/** 23334 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError 23335 * if value is a number. 23336 * Buffer.from(str[, encoding]) 23337 * Buffer.from(array) 23338 * Buffer.from(buffer) 23339 * Buffer.from(arrayBuffer[, byteOffset[, length]]) 23340 **/ 23341Buffer.from = function (value, encodingOrOffset, length) { 23342 return from(value, encodingOrOffset, length) 23343} 23344 23345// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug: 23346// https://github.com/feross/buffer/pull/148 23347Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype) 23348Object.setPrototypeOf(Buffer, Uint8Array) 23349 23350function assertSize (size) { 23351 if (typeof size !== 'number') { 23352 throw new TypeError('"size" argument must be of type number') 23353 } else if (size < 0) { 23354 throw new RangeError('The value "' + size + '" is invalid for option "size"') 23355 } 23356} 23357 23358function alloc (size, fill, encoding) { 23359 assertSize(size) 23360 if (size <= 0) { 23361 return createBuffer(size) 23362 } 23363 if (fill !== undefined) { 23364 // Only pay attention to encoding if it's a string. This 23365 // prevents accidentally sending in a number that would 23366 // be interpreted as a start offset. 23367 return typeof encoding === 'string' 23368 ? createBuffer(size).fill(fill, encoding) 23369 : createBuffer(size).fill(fill) 23370 } 23371 return createBuffer(size) 23372} 23373 23374/** 23375 * Creates a new filled Buffer instance. 23376 * alloc(size[, fill[, encoding]]) 23377 **/ 23378Buffer.alloc = function (size, fill, encoding) { 23379 return alloc(size, fill, encoding) 23380} 23381 23382function allocUnsafe (size) { 23383 assertSize(size) 23384 return createBuffer(size < 0 ? 0 : checked(size) | 0) 23385} 23386 23387/** 23388 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. 23389 * */ 23390Buffer.allocUnsafe = function (size) { 23391 return allocUnsafe(size) 23392} 23393/** 23394 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. 23395 */ 23396Buffer.allocUnsafeSlow = function (size) { 23397 return allocUnsafe(size) 23398} 23399 23400function fromString (string, encoding) { 23401 if (typeof encoding !== 'string' || encoding === '') { 23402 encoding = 'utf8' 23403 } 23404 23405 if (!Buffer.isEncoding(encoding)) { 23406 throw new TypeError('Unknown encoding: ' + encoding) 23407 } 23408 23409 var length = byteLength(string, encoding) | 0 23410 var buf = createBuffer(length) 23411 23412 var actual = buf.write(string, encoding) 23413 23414 if (actual !== length) { 23415 // Writing a hex string, for example, that contains invalid characters will 23416 // cause everything after the first invalid character to be ignored. (e.g. 23417 // 'abxxcd' will be treated as 'ab') 23418 buf = buf.slice(0, actual) 23419 } 23420 23421 return buf 23422} 23423 23424function fromArrayLike (array) { 23425 var length = array.length < 0 ? 0 : checked(array.length) | 0 23426 var buf = createBuffer(length) 23427 for (var i = 0; i < length; i += 1) { 23428 buf[i] = array[i] & 255 23429 } 23430 return buf 23431} 23432 23433function fromArrayView (arrayView) { 23434 if (isInstance(arrayView, Uint8Array)) { 23435 var copy = new Uint8Array(arrayView) 23436 return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength) 23437 } 23438 return fromArrayLike(arrayView) 23439} 23440 23441function fromArrayBuffer (array, byteOffset, length) { 23442 if (byteOffset < 0 || array.byteLength < byteOffset) { 23443 throw new RangeError('"offset" is outside of buffer bounds') 23444 } 23445 23446 if (array.byteLength < byteOffset + (length || 0)) { 23447 throw new RangeError('"length" is outside of buffer bounds') 23448 } 23449 23450 var buf 23451 if (byteOffset === undefined && length === undefined) { 23452 buf = new Uint8Array(array) 23453 } else if (length === undefined) { 23454 buf = new Uint8Array(array, byteOffset) 23455 } else { 23456 buf = new Uint8Array(array, byteOffset, length) 23457 } 23458 23459 // Return an augmented `Uint8Array` instance 23460 Object.setPrototypeOf(buf, Buffer.prototype) 23461 23462 return buf 23463} 23464 23465function fromObject (obj) { 23466 if (Buffer.isBuffer(obj)) { 23467 var len = checked(obj.length) | 0 23468 var buf = createBuffer(len) 23469 23470 if (buf.length === 0) { 23471 return buf 23472 } 23473 23474 obj.copy(buf, 0, 0, len) 23475 return buf 23476 } 23477 23478 if (obj.length !== undefined) { 23479 if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) { 23480 return createBuffer(0) 23481 } 23482 return fromArrayLike(obj) 23483 } 23484 23485 if (obj.type === 'Buffer' && Array.isArray(obj.data)) { 23486 return fromArrayLike(obj.data) 23487 } 23488} 23489 23490function checked (length) { 23491 // Note: cannot use `length < K_MAX_LENGTH` here because that fails when 23492 // length is NaN (which is otherwise coerced to zero.) 23493 if (length >= K_MAX_LENGTH) { 23494 throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 23495 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes') 23496 } 23497 return length | 0 23498} 23499 23500function SlowBuffer (length) { 23501 if (+length != length) { // eslint-disable-line eqeqeq 23502 length = 0 23503 } 23504 return Buffer.alloc(+length) 23505} 23506 23507Buffer.isBuffer = function isBuffer (b) { 23508 return b != null && b._isBuffer === true && 23509 b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false 23510} 23511 23512Buffer.compare = function compare (a, b) { 23513 if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength) 23514 if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength) 23515 if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { 23516 throw new TypeError( 23517 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' 23518 ) 23519 } 23520 23521 if (a === b) return 0 23522 23523 var x = a.length 23524 var y = b.length 23525 23526 for (var i = 0, len = Math.min(x, y); i < len; ++i) { 23527 if (a[i] !== b[i]) { 23528 x = a[i] 23529 y = b[i] 23530 break 23531 } 23532 } 23533 23534 if (x < y) return -1 23535 if (y < x) return 1 23536 return 0 23537} 23538 23539Buffer.isEncoding = function isEncoding (encoding) { 23540 switch (String(encoding).toLowerCase()) { 23541 case 'hex': 23542 case 'utf8': 23543 case 'utf-8': 23544 case 'ascii': 23545 case 'latin1': 23546 case 'binary': 23547 case 'base64': 23548 case 'ucs2': 23549 case 'ucs-2': 23550 case 'utf16le': 23551 case 'utf-16le': 23552 return true 23553 default: 23554 return false 23555 } 23556} 23557 23558Buffer.concat = function concat (list, length) { 23559 if (!Array.isArray(list)) { 23560 throw new TypeError('"list" argument must be an Array of Buffers') 23561 } 23562 23563 if (list.length === 0) { 23564 return Buffer.alloc(0) 23565 } 23566 23567 var i 23568 if (length === undefined) { 23569 length = 0 23570 for (i = 0; i < list.length; ++i) { 23571 length += list[i].length 23572 } 23573 } 23574 23575 var buffer = Buffer.allocUnsafe(length) 23576 var pos = 0 23577 for (i = 0; i < list.length; ++i) { 23578 var buf = list[i] 23579 if (isInstance(buf, Uint8Array)) { 23580 if (pos + buf.length > buffer.length) { 23581 Buffer.from(buf).copy(buffer, pos) 23582 } else { 23583 Uint8Array.prototype.set.call( 23584 buffer, 23585 buf, 23586 pos 23587 ) 23588 } 23589 } else if (!Buffer.isBuffer(buf)) { 23590 throw new TypeError('"list" argument must be an Array of Buffers') 23591 } else { 23592 buf.copy(buffer, pos) 23593 } 23594 pos += buf.length 23595 } 23596 return buffer 23597} 23598 23599function byteLength (string, encoding) { 23600 if (Buffer.isBuffer(string)) { 23601 return string.length 23602 } 23603 if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { 23604 return string.byteLength 23605 } 23606 if (typeof string !== 'string') { 23607 throw new TypeError( 23608 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' + 23609 'Received type ' + typeof string 23610 ) 23611 } 23612 23613 var len = string.length 23614 var mustMatch = (arguments.length > 2 && arguments[2] === true) 23615 if (!mustMatch && len === 0) return 0 23616 23617 // Use a for loop to avoid recursion 23618 var loweredCase = false 23619 for (;;) { 23620 switch (encoding) { 23621 case 'ascii': 23622 case 'latin1': 23623 case 'binary': 23624 return len 23625 case 'utf8': 23626 case 'utf-8': 23627 return utf8ToBytes(string).length 23628 case 'ucs2': 23629 case 'ucs-2': 23630 case 'utf16le': 23631 case 'utf-16le': 23632 return len * 2 23633 case 'hex': 23634 return len >>> 1 23635 case 'base64': 23636 return base64ToBytes(string).length 23637 default: 23638 if (loweredCase) { 23639 return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8 23640 } 23641 encoding = ('' + encoding).toLowerCase() 23642 loweredCase = true 23643 } 23644 } 23645} 23646Buffer.byteLength = byteLength 23647 23648function slowToString (encoding, start, end) { 23649 var loweredCase = false 23650 23651 // No need to verify that "this.length <= MAX_UINT32" since it's a read-only 23652 // property of a typed array. 23653 23654 // This behaves neither like String nor Uint8Array in that we set start/end 23655 // to their upper/lower bounds if the value passed is out of range. 23656 // undefined is handled specially as per ECMA-262 6th Edition, 23657 // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. 23658 if (start === undefined || start < 0) { 23659 start = 0 23660 } 23661 // Return early if start > this.length. Done here to prevent potential uint32 23662 // coercion fail below. 23663 if (start > this.length) { 23664 return '' 23665 } 23666 23667 if (end === undefined || end > this.length) { 23668 end = this.length 23669 } 23670 23671 if (end <= 0) { 23672 return '' 23673 } 23674 23675 // Force coercion to uint32. This will also coerce falsey/NaN values to 0. 23676 end >>>= 0 23677 start >>>= 0 23678 23679 if (end <= start) { 23680 return '' 23681 } 23682 23683 if (!encoding) encoding = 'utf8' 23684 23685 while (true) { 23686 switch (encoding) { 23687 case 'hex': 23688 return hexSlice(this, start, end) 23689 23690 case 'utf8': 23691 case 'utf-8': 23692 return utf8Slice(this, start, end) 23693 23694 case 'ascii': 23695 return asciiSlice(this, start, end) 23696 23697 case 'latin1': 23698 case 'binary': 23699 return latin1Slice(this, start, end) 23700 23701 case 'base64': 23702 return base64Slice(this, start, end) 23703 23704 case 'ucs2': 23705 case 'ucs-2': 23706 case 'utf16le': 23707 case 'utf-16le': 23708 return utf16leSlice(this, start, end) 23709 23710 default: 23711 if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) 23712 encoding = (encoding + '').toLowerCase() 23713 loweredCase = true 23714 } 23715 } 23716} 23717 23718// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package) 23719// to detect a Buffer instance. It's not possible to use `instanceof Buffer` 23720// reliably in a browserify context because there could be multiple different 23721// copies of the 'buffer' package in use. This method works even for Buffer 23722// instances that were created from another copy of the `buffer` package. 23723// See: https://github.com/feross/buffer/issues/154 23724Buffer.prototype._isBuffer = true 23725 23726function swap (b, n, m) { 23727 var i = b[n] 23728 b[n] = b[m] 23729 b[m] = i 23730} 23731 23732Buffer.prototype.swap16 = function swap16 () { 23733 var len = this.length 23734 if (len % 2 !== 0) { 23735 throw new RangeError('Buffer size must be a multiple of 16-bits') 23736 } 23737 for (var i = 0; i < len; i += 2) { 23738 swap(this, i, i + 1) 23739 } 23740 return this 23741} 23742 23743Buffer.prototype.swap32 = function swap32 () { 23744 var len = this.length 23745 if (len % 4 !== 0) { 23746 throw new RangeError('Buffer size must be a multiple of 32-bits') 23747 } 23748 for (var i = 0; i < len; i += 4) { 23749 swap(this, i, i + 3) 23750 swap(this, i + 1, i + 2) 23751 } 23752 return this 23753} 23754 23755Buffer.prototype.swap64 = function swap64 () { 23756 var len = this.length 23757 if (len % 8 !== 0) { 23758 throw new RangeError('Buffer size must be a multiple of 64-bits') 23759 } 23760 for (var i = 0; i < len; i += 8) { 23761 swap(this, i, i + 7) 23762 swap(this, i + 1, i + 6) 23763 swap(this, i + 2, i + 5) 23764 swap(this, i + 3, i + 4) 23765 } 23766 return this 23767} 23768 23769Buffer.prototype.toString = function toString () { 23770 var length = this.length 23771 if (length === 0) return '' 23772 if (arguments.length === 0) return utf8Slice(this, 0, length) 23773 return slowToString.apply(this, arguments) 23774} 23775 23776Buffer.prototype.toLocaleString = Buffer.prototype.toString 23777 23778Buffer.prototype.equals = function equals (b) { 23779 if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') 23780 if (this === b) return true 23781 return Buffer.compare(this, b) === 0 23782} 23783 23784Buffer.prototype.inspect = function inspect () { 23785 var str = '' 23786 var max = exports.INSPECT_MAX_BYTES 23787 str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim() 23788 if (this.length > max) str += ' ... ' 23789 return '<Buffer ' + str + '>' 23790} 23791if (customInspectSymbol) { 23792 Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect 23793} 23794 23795Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { 23796 if (isInstance(target, Uint8Array)) { 23797 target = Buffer.from(target, target.offset, target.byteLength) 23798 } 23799 if (!Buffer.isBuffer(target)) { 23800 throw new TypeError( 23801 'The "target" argument must be one of type Buffer or Uint8Array. ' + 23802 'Received type ' + (typeof target) 23803 ) 23804 } 23805 23806 if (start === undefined) { 23807 start = 0 23808 } 23809 if (end === undefined) { 23810 end = target ? target.length : 0 23811 } 23812 if (thisStart === undefined) { 23813 thisStart = 0 23814 } 23815 if (thisEnd === undefined) { 23816 thisEnd = this.length 23817 } 23818 23819 if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { 23820 throw new RangeError('out of range index') 23821 } 23822 23823 if (thisStart >= thisEnd && start >= end) { 23824 return 0 23825 } 23826 if (thisStart >= thisEnd) { 23827 return -1 23828 } 23829 if (start >= end) { 23830 return 1 23831 } 23832 23833 start >>>= 0 23834 end >>>= 0 23835 thisStart >>>= 0 23836 thisEnd >>>= 0 23837 23838 if (this === target) return 0 23839 23840 var x = thisEnd - thisStart 23841 var y = end - start 23842 var len = Math.min(x, y) 23843 23844 var thisCopy = this.slice(thisStart, thisEnd) 23845 var targetCopy = target.slice(start, end) 23846 23847 for (var i = 0; i < len; ++i) { 23848 if (thisCopy[i] !== targetCopy[i]) { 23849 x = thisCopy[i] 23850 y = targetCopy[i] 23851 break 23852 } 23853 } 23854 23855 if (x < y) return -1 23856 if (y < x) return 1 23857 return 0 23858} 23859 23860// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, 23861// OR the last index of `val` in `buffer` at offset <= `byteOffset`. 23862// 23863// Arguments: 23864// - buffer - a Buffer to search 23865// - val - a string, Buffer, or number 23866// - byteOffset - an index into `buffer`; will be clamped to an int32 23867// - encoding - an optional encoding, relevant is val is a string 23868// - dir - true for indexOf, false for lastIndexOf 23869function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { 23870 // Empty buffer means no match 23871 if (buffer.length === 0) return -1 23872 23873 // Normalize byteOffset 23874 if (typeof byteOffset === 'string') { 23875 encoding = byteOffset 23876 byteOffset = 0 23877 } else if (byteOffset > 0x7fffffff) { 23878 byteOffset = 0x7fffffff 23879 } else if (byteOffset < -0x80000000) { 23880 byteOffset = -0x80000000 23881 } 23882 byteOffset = +byteOffset // Coerce to Number. 23883 if (numberIsNaN(byteOffset)) { 23884 // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer 23885 byteOffset = dir ? 0 : (buffer.length - 1) 23886 } 23887 23888 // Normalize byteOffset: negative offsets start from the end of the buffer 23889 if (byteOffset < 0) byteOffset = buffer.length + byteOffset 23890 if (byteOffset >= buffer.length) { 23891 if (dir) return -1 23892 else byteOffset = buffer.length - 1 23893 } else if (byteOffset < 0) { 23894 if (dir) byteOffset = 0 23895 else return -1 23896 } 23897 23898 // Normalize val 23899 if (typeof val === 'string') { 23900 val = Buffer.from(val, encoding) 23901 } 23902 23903 // Finally, search either indexOf (if dir is true) or lastIndexOf 23904 if (Buffer.isBuffer(val)) { 23905 // Special case: looking for empty string/buffer always fails 23906 if (val.length === 0) { 23907 return -1 23908 } 23909 return arrayIndexOf(buffer, val, byteOffset, encoding, dir) 23910 } else if (typeof val === 'number') { 23911 val = val & 0xFF // Search for a byte value [0-255] 23912 if (typeof Uint8Array.prototype.indexOf === 'function') { 23913 if (dir) { 23914 return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) 23915 } else { 23916 return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) 23917 } 23918 } 23919 return arrayIndexOf(buffer, [val], byteOffset, encoding, dir) 23920 } 23921 23922 throw new TypeError('val must be string, number or Buffer') 23923} 23924 23925function arrayIndexOf (arr, val, byteOffset, encoding, dir) { 23926 var indexSize = 1 23927 var arrLength = arr.length 23928 var valLength = val.length 23929 23930 if (encoding !== undefined) { 23931 encoding = String(encoding).toLowerCase() 23932 if (encoding === 'ucs2' || encoding === 'ucs-2' || 23933 encoding === 'utf16le' || encoding === 'utf-16le') { 23934 if (arr.length < 2 || val.length < 2) { 23935 return -1 23936 } 23937 indexSize = 2 23938 arrLength /= 2 23939 valLength /= 2 23940 byteOffset /= 2 23941 } 23942 } 23943 23944 function read (buf, i) { 23945 if (indexSize === 1) { 23946 return buf[i] 23947 } else { 23948 return buf.readUInt16BE(i * indexSize) 23949 } 23950 } 23951 23952 var i 23953 if (dir) { 23954 var foundIndex = -1 23955 for (i = byteOffset; i < arrLength; i++) { 23956 if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { 23957 if (foundIndex === -1) foundIndex = i 23958 if (i - foundIndex + 1 === valLength) return foundIndex * indexSize 23959 } else { 23960 if (foundIndex !== -1) i -= i - foundIndex 23961 foundIndex = -1 23962 } 23963 } 23964 } else { 23965 if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength 23966 for (i = byteOffset; i >= 0; i--) { 23967 var found = true 23968 for (var j = 0; j < valLength; j++) { 23969 if (read(arr, i + j) !== read(val, j)) { 23970 found = false 23971 break 23972 } 23973 } 23974 if (found) return i 23975 } 23976 } 23977 23978 return -1 23979} 23980 23981Buffer.prototype.includes = function includes (val, byteOffset, encoding) { 23982 return this.indexOf(val, byteOffset, encoding) !== -1 23983} 23984 23985Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { 23986 return bidirectionalIndexOf(this, val, byteOffset, encoding, true) 23987} 23988 23989Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { 23990 return bidirectionalIndexOf(this, val, byteOffset, encoding, false) 23991} 23992 23993function hexWrite (buf, string, offset, length) { 23994 offset = Number(offset) || 0 23995 var remaining = buf.length - offset 23996 if (!length) { 23997 length = remaining 23998 } else { 23999 length = Number(length) 24000 if (length > remaining) { 24001 length = remaining 24002 } 24003 } 24004 24005 var strLen = string.length 24006 24007 if (length > strLen / 2) { 24008 length = strLen / 2 24009 } 24010 for (var i = 0; i < length; ++i) { 24011 var parsed = parseInt(string.substr(i * 2, 2), 16) 24012 if (numberIsNaN(parsed)) return i 24013 buf[offset + i] = parsed 24014 } 24015 return i 24016} 24017 24018function utf8Write (buf, string, offset, length) { 24019 return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) 24020} 24021 24022function asciiWrite (buf, string, offset, length) { 24023 return blitBuffer(asciiToBytes(string), buf, offset, length) 24024} 24025 24026function base64Write (buf, string, offset, length) { 24027 return blitBuffer(base64ToBytes(string), buf, offset, length) 24028} 24029 24030function ucs2Write (buf, string, offset, length) { 24031 return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) 24032} 24033 24034Buffer.prototype.write = function write (string, offset, length, encoding) { 24035 // Buffer#write(string) 24036 if (offset === undefined) { 24037 encoding = 'utf8' 24038 length = this.length 24039 offset = 0 24040 // Buffer#write(string, encoding) 24041 } else if (length === undefined && typeof offset === 'string') { 24042 encoding = offset 24043 length = this.length 24044 offset = 0 24045 // Buffer#write(string, offset[, length][, encoding]) 24046 } else if (isFinite(offset)) { 24047 offset = offset >>> 0 24048 if (isFinite(length)) { 24049 length = length >>> 0 24050 if (encoding === undefined) encoding = 'utf8' 24051 } else { 24052 encoding = length 24053 length = undefined 24054 } 24055 } else { 24056 throw new Error( 24057 'Buffer.write(string, encoding, offset[, length]) is no longer supported' 24058 ) 24059 } 24060 24061 var remaining = this.length - offset 24062 if (length === undefined || length > remaining) length = remaining 24063 24064 if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { 24065 throw new RangeError('Attempt to write outside buffer bounds') 24066 } 24067 24068 if (!encoding) encoding = 'utf8' 24069 24070 var loweredCase = false 24071 for (;;) { 24072 switch (encoding) { 24073 case 'hex': 24074 return hexWrite(this, string, offset, length) 24075 24076 case 'utf8': 24077 case 'utf-8': 24078 return utf8Write(this, string, offset, length) 24079 24080 case 'ascii': 24081 case 'latin1': 24082 case 'binary': 24083 return asciiWrite(this, string, offset, length) 24084 24085 case 'base64': 24086 // Warning: maxLength not taken into account in base64Write 24087 return base64Write(this, string, offset, length) 24088 24089 case 'ucs2': 24090 case 'ucs-2': 24091 case 'utf16le': 24092 case 'utf-16le': 24093 return ucs2Write(this, string, offset, length) 24094 24095 default: 24096 if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) 24097 encoding = ('' + encoding).toLowerCase() 24098 loweredCase = true 24099 } 24100 } 24101} 24102 24103Buffer.prototype.toJSON = function toJSON () { 24104 return { 24105 type: 'Buffer', 24106 data: Array.prototype.slice.call(this._arr || this, 0) 24107 } 24108} 24109 24110function base64Slice (buf, start, end) { 24111 if (start === 0 && end === buf.length) { 24112 return base64.fromByteArray(buf) 24113 } else { 24114 return base64.fromByteArray(buf.slice(start, end)) 24115 } 24116} 24117 24118function utf8Slice (buf, start, end) { 24119 end = Math.min(buf.length, end) 24120 var res = [] 24121 24122 var i = start 24123 while (i < end) { 24124 var firstByte = buf[i] 24125 var codePoint = null 24126 var bytesPerSequence = (firstByte > 0xEF) 24127 ? 4 24128 : (firstByte > 0xDF) 24129 ? 3 24130 : (firstByte > 0xBF) 24131 ? 2 24132 : 1 24133 24134 if (i + bytesPerSequence <= end) { 24135 var secondByte, thirdByte, fourthByte, tempCodePoint 24136 24137 switch (bytesPerSequence) { 24138 case 1: 24139 if (firstByte < 0x80) { 24140 codePoint = firstByte 24141 } 24142 break 24143 case 2: 24144 secondByte = buf[i + 1] 24145 if ((secondByte & 0xC0) === 0x80) { 24146 tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) 24147 if (tempCodePoint > 0x7F) { 24148 codePoint = tempCodePoint 24149 } 24150 } 24151 break 24152 case 3: 24153 secondByte = buf[i + 1] 24154 thirdByte = buf[i + 2] 24155 if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { 24156 tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) 24157 if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { 24158 codePoint = tempCodePoint 24159 } 24160 } 24161 break 24162 case 4: 24163 secondByte = buf[i + 1] 24164 thirdByte = buf[i + 2] 24165 fourthByte = buf[i + 3] 24166 if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { 24167 tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) 24168 if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { 24169 codePoint = tempCodePoint 24170 } 24171 } 24172 } 24173 } 24174 24175 if (codePoint === null) { 24176 // we did not generate a valid codePoint so insert a 24177 // replacement char (U+FFFD) and advance only 1 byte 24178 codePoint = 0xFFFD 24179 bytesPerSequence = 1 24180 } else if (codePoint > 0xFFFF) { 24181 // encode to utf16 (surrogate pair dance) 24182 codePoint -= 0x10000 24183 res.push(codePoint >>> 10 & 0x3FF | 0xD800) 24184 codePoint = 0xDC00 | codePoint & 0x3FF 24185 } 24186 24187 res.push(codePoint) 24188 i += bytesPerSequence 24189 } 24190 24191 return decodeCodePointsArray(res) 24192} 24193 24194// Based on http://stackoverflow.com/a/22747272/680742, the browser with 24195// the lowest limit is Chrome, with 0x10000 args. 24196// We go 1 magnitude less, for safety 24197var MAX_ARGUMENTS_LENGTH = 0x1000 24198 24199function decodeCodePointsArray (codePoints) { 24200 var len = codePoints.length 24201 if (len <= MAX_ARGUMENTS_LENGTH) { 24202 return String.fromCharCode.apply(String, codePoints) // avoid extra slice() 24203 } 24204 24205 // Decode in chunks to avoid "call stack size exceeded". 24206 var res = '' 24207 var i = 0 24208 while (i < len) { 24209 res += String.fromCharCode.apply( 24210 String, 24211 codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) 24212 ) 24213 } 24214 return res 24215} 24216 24217function asciiSlice (buf, start, end) { 24218 var ret = '' 24219 end = Math.min(buf.length, end) 24220 24221 for (var i = start; i < end; ++i) { 24222 ret += String.fromCharCode(buf[i] & 0x7F) 24223 } 24224 return ret 24225} 24226 24227function latin1Slice (buf, start, end) { 24228 var ret = '' 24229 end = Math.min(buf.length, end) 24230 24231 for (var i = start; i < end; ++i) { 24232 ret += String.fromCharCode(buf[i]) 24233 } 24234 return ret 24235} 24236 24237function hexSlice (buf, start, end) { 24238 var len = buf.length 24239 24240 if (!start || start < 0) start = 0 24241 if (!end || end < 0 || end > len) end = len 24242 24243 var out = '' 24244 for (var i = start; i < end; ++i) { 24245 out += hexSliceLookupTable[buf[i]] 24246 } 24247 return out 24248} 24249 24250function utf16leSlice (buf, start, end) { 24251 var bytes = buf.slice(start, end) 24252 var res = '' 24253 // If bytes.length is odd, the last 8 bits must be ignored (same as node.js) 24254 for (var i = 0; i < bytes.length - 1; i += 2) { 24255 res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256)) 24256 } 24257 return res 24258} 24259 24260Buffer.prototype.slice = function slice (start, end) { 24261 var len = this.length 24262 start = ~~start 24263 end = end === undefined ? len : ~~end 24264 24265 if (start < 0) { 24266 start += len 24267 if (start < 0) start = 0 24268 } else if (start > len) { 24269 start = len 24270 } 24271 24272 if (end < 0) { 24273 end += len 24274 if (end < 0) end = 0 24275 } else if (end > len) { 24276 end = len 24277 } 24278 24279 if (end < start) end = start 24280 24281 var newBuf = this.subarray(start, end) 24282 // Return an augmented `Uint8Array` instance 24283 Object.setPrototypeOf(newBuf, Buffer.prototype) 24284 24285 return newBuf 24286} 24287 24288/* 24289 * Need to make sure that buffer isn't trying to write out of bounds. 24290 */ 24291function checkOffset (offset, ext, length) { 24292 if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') 24293 if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') 24294} 24295 24296Buffer.prototype.readUintLE = 24297Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { 24298 offset = offset >>> 0 24299 byteLength = byteLength >>> 0 24300 if (!noAssert) checkOffset(offset, byteLength, this.length) 24301 24302 var val = this[offset] 24303 var mul = 1 24304 var i = 0 24305 while (++i < byteLength && (mul *= 0x100)) { 24306 val += this[offset + i] * mul 24307 } 24308 24309 return val 24310} 24311 24312Buffer.prototype.readUintBE = 24313Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { 24314 offset = offset >>> 0 24315 byteLength = byteLength >>> 0 24316 if (!noAssert) { 24317 checkOffset(offset, byteLength, this.length) 24318 } 24319 24320 var val = this[offset + --byteLength] 24321 var mul = 1 24322 while (byteLength > 0 && (mul *= 0x100)) { 24323 val += this[offset + --byteLength] * mul 24324 } 24325 24326 return val 24327} 24328 24329Buffer.prototype.readUint8 = 24330Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { 24331 offset = offset >>> 0 24332 if (!noAssert) checkOffset(offset, 1, this.length) 24333 return this[offset] 24334} 24335 24336Buffer.prototype.readUint16LE = 24337Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { 24338 offset = offset >>> 0 24339 if (!noAssert) checkOffset(offset, 2, this.length) 24340 return this[offset] | (this[offset + 1] << 8) 24341} 24342 24343Buffer.prototype.readUint16BE = 24344Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { 24345 offset = offset >>> 0 24346 if (!noAssert) checkOffset(offset, 2, this.length) 24347 return (this[offset] << 8) | this[offset + 1] 24348} 24349 24350Buffer.prototype.readUint32LE = 24351Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { 24352 offset = offset >>> 0 24353 if (!noAssert) checkOffset(offset, 4, this.length) 24354 24355 return ((this[offset]) | 24356 (this[offset + 1] << 8) | 24357 (this[offset + 2] << 16)) + 24358 (this[offset + 3] * 0x1000000) 24359} 24360 24361Buffer.prototype.readUint32BE = 24362Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { 24363 offset = offset >>> 0 24364 if (!noAssert) checkOffset(offset, 4, this.length) 24365 24366 return (this[offset] * 0x1000000) + 24367 ((this[offset + 1] << 16) | 24368 (this[offset + 2] << 8) | 24369 this[offset + 3]) 24370} 24371 24372Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { 24373 offset = offset >>> 0 24374 byteLength = byteLength >>> 0 24375 if (!noAssert) checkOffset(offset, byteLength, this.length) 24376 24377 var val = this[offset] 24378 var mul = 1 24379 var i = 0 24380 while (++i < byteLength && (mul *= 0x100)) { 24381 val += this[offset + i] * mul 24382 } 24383 mul *= 0x80 24384 24385 if (val >= mul) val -= Math.pow(2, 8 * byteLength) 24386 24387 return val 24388} 24389 24390Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { 24391 offset = offset >>> 0 24392 byteLength = byteLength >>> 0 24393 if (!noAssert) checkOffset(offset, byteLength, this.length) 24394 24395 var i = byteLength 24396 var mul = 1 24397 var val = this[offset + --i] 24398 while (i > 0 && (mul *= 0x100)) { 24399 val += this[offset + --i] * mul 24400 } 24401 mul *= 0x80 24402 24403 if (val >= mul) val -= Math.pow(2, 8 * byteLength) 24404 24405 return val 24406} 24407 24408Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { 24409 offset = offset >>> 0 24410 if (!noAssert) checkOffset(offset, 1, this.length) 24411 if (!(this[offset] & 0x80)) return (this[offset]) 24412 return ((0xff - this[offset] + 1) * -1) 24413} 24414 24415Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { 24416 offset = offset >>> 0 24417 if (!noAssert) checkOffset(offset, 2, this.length) 24418 var val = this[offset] | (this[offset + 1] << 8) 24419 return (val & 0x8000) ? val | 0xFFFF0000 : val 24420} 24421 24422Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { 24423 offset = offset >>> 0 24424 if (!noAssert) checkOffset(offset, 2, this.length) 24425 var val = this[offset + 1] | (this[offset] << 8) 24426 return (val & 0x8000) ? val | 0xFFFF0000 : val 24427} 24428 24429Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { 24430 offset = offset >>> 0 24431 if (!noAssert) checkOffset(offset, 4, this.length) 24432 24433 return (this[offset]) | 24434 (this[offset + 1] << 8) | 24435 (this[offset + 2] << 16) | 24436 (this[offset + 3] << 24) 24437} 24438 24439Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { 24440 offset = offset >>> 0 24441 if (!noAssert) checkOffset(offset, 4, this.length) 24442 24443 return (this[offset] << 24) | 24444 (this[offset + 1] << 16) | 24445 (this[offset + 2] << 8) | 24446 (this[offset + 3]) 24447} 24448 24449Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { 24450 offset = offset >>> 0 24451 if (!noAssert) checkOffset(offset, 4, this.length) 24452 return ieee754.read(this, offset, true, 23, 4) 24453} 24454 24455Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { 24456 offset = offset >>> 0 24457 if (!noAssert) checkOffset(offset, 4, this.length) 24458 return ieee754.read(this, offset, false, 23, 4) 24459} 24460 24461Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { 24462 offset = offset >>> 0 24463 if (!noAssert) checkOffset(offset, 8, this.length) 24464 return ieee754.read(this, offset, true, 52, 8) 24465} 24466 24467Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { 24468 offset = offset >>> 0 24469 if (!noAssert) checkOffset(offset, 8, this.length) 24470 return ieee754.read(this, offset, false, 52, 8) 24471} 24472 24473function checkInt (buf, value, offset, ext, max, min) { 24474 if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') 24475 if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') 24476 if (offset + ext > buf.length) throw new RangeError('Index out of range') 24477} 24478 24479Buffer.prototype.writeUintLE = 24480Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { 24481 value = +value 24482 offset = offset >>> 0 24483 byteLength = byteLength >>> 0 24484 if (!noAssert) { 24485 var maxBytes = Math.pow(2, 8 * byteLength) - 1 24486 checkInt(this, value, offset, byteLength, maxBytes, 0) 24487 } 24488 24489 var mul = 1 24490 var i = 0 24491 this[offset] = value & 0xFF 24492 while (++i < byteLength && (mul *= 0x100)) { 24493 this[offset + i] = (value / mul) & 0xFF 24494 } 24495 24496 return offset + byteLength 24497} 24498 24499Buffer.prototype.writeUintBE = 24500Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { 24501 value = +value 24502 offset = offset >>> 0 24503 byteLength = byteLength >>> 0 24504 if (!noAssert) { 24505 var maxBytes = Math.pow(2, 8 * byteLength) - 1 24506 checkInt(this, value, offset, byteLength, maxBytes, 0) 24507 } 24508 24509 var i = byteLength - 1 24510 var mul = 1 24511 this[offset + i] = value & 0xFF 24512 while (--i >= 0 && (mul *= 0x100)) { 24513 this[offset + i] = (value / mul) & 0xFF 24514 } 24515 24516 return offset + byteLength 24517} 24518 24519Buffer.prototype.writeUint8 = 24520Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { 24521 value = +value 24522 offset = offset >>> 0 24523 if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) 24524 this[offset] = (value & 0xff) 24525 return offset + 1 24526} 24527 24528Buffer.prototype.writeUint16LE = 24529Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { 24530 value = +value 24531 offset = offset >>> 0 24532 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) 24533 this[offset] = (value & 0xff) 24534 this[offset + 1] = (value >>> 8) 24535 return offset + 2 24536} 24537 24538Buffer.prototype.writeUint16BE = 24539Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { 24540 value = +value 24541 offset = offset >>> 0 24542 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) 24543 this[offset] = (value >>> 8) 24544 this[offset + 1] = (value & 0xff) 24545 return offset + 2 24546} 24547 24548Buffer.prototype.writeUint32LE = 24549Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { 24550 value = +value 24551 offset = offset >>> 0 24552 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) 24553 this[offset + 3] = (value >>> 24) 24554 this[offset + 2] = (value >>> 16) 24555 this[offset + 1] = (value >>> 8) 24556 this[offset] = (value & 0xff) 24557 return offset + 4 24558} 24559 24560Buffer.prototype.writeUint32BE = 24561Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { 24562 value = +value 24563 offset = offset >>> 0 24564 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) 24565 this[offset] = (value >>> 24) 24566 this[offset + 1] = (value >>> 16) 24567 this[offset + 2] = (value >>> 8) 24568 this[offset + 3] = (value & 0xff) 24569 return offset + 4 24570} 24571 24572Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { 24573 value = +value 24574 offset = offset >>> 0 24575 if (!noAssert) { 24576 var limit = Math.pow(2, (8 * byteLength) - 1) 24577 24578 checkInt(this, value, offset, byteLength, limit - 1, -limit) 24579 } 24580 24581 var i = 0 24582 var mul = 1 24583 var sub = 0 24584 this[offset] = value & 0xFF 24585 while (++i < byteLength && (mul *= 0x100)) { 24586 if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { 24587 sub = 1 24588 } 24589 this[offset + i] = ((value / mul) >> 0) - sub & 0xFF 24590 } 24591 24592 return offset + byteLength 24593} 24594 24595Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { 24596 value = +value 24597 offset = offset >>> 0 24598 if (!noAssert) { 24599 var limit = Math.pow(2, (8 * byteLength) - 1) 24600 24601 checkInt(this, value, offset, byteLength, limit - 1, -limit) 24602 } 24603 24604 var i = byteLength - 1 24605 var mul = 1 24606 var sub = 0 24607 this[offset + i] = value & 0xFF 24608 while (--i >= 0 && (mul *= 0x100)) { 24609 if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { 24610 sub = 1 24611 } 24612 this[offset + i] = ((value / mul) >> 0) - sub & 0xFF 24613 } 24614 24615 return offset + byteLength 24616} 24617 24618Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { 24619 value = +value 24620 offset = offset >>> 0 24621 if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) 24622 if (value < 0) value = 0xff + value + 1 24623 this[offset] = (value & 0xff) 24624 return offset + 1 24625} 24626 24627Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { 24628 value = +value 24629 offset = offset >>> 0 24630 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) 24631 this[offset] = (value & 0xff) 24632 this[offset + 1] = (value >>> 8) 24633 return offset + 2 24634} 24635 24636Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { 24637 value = +value 24638 offset = offset >>> 0 24639 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) 24640 this[offset] = (value >>> 8) 24641 this[offset + 1] = (value & 0xff) 24642 return offset + 2 24643} 24644 24645Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { 24646 value = +value 24647 offset = offset >>> 0 24648 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) 24649 this[offset] = (value & 0xff) 24650 this[offset + 1] = (value >>> 8) 24651 this[offset + 2] = (value >>> 16) 24652 this[offset + 3] = (value >>> 24) 24653 return offset + 4 24654} 24655 24656Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { 24657 value = +value 24658 offset = offset >>> 0 24659 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) 24660 if (value < 0) value = 0xffffffff + value + 1 24661 this[offset] = (value >>> 24) 24662 this[offset + 1] = (value >>> 16) 24663 this[offset + 2] = (value >>> 8) 24664 this[offset + 3] = (value & 0xff) 24665 return offset + 4 24666} 24667 24668function checkIEEE754 (buf, value, offset, ext, max, min) { 24669 if (offset + ext > buf.length) throw new RangeError('Index out of range') 24670 if (offset < 0) throw new RangeError('Index out of range') 24671} 24672 24673function writeFloat (buf, value, offset, littleEndian, noAssert) { 24674 value = +value 24675 offset = offset >>> 0 24676 if (!noAssert) { 24677 checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) 24678 } 24679 ieee754.write(buf, value, offset, littleEndian, 23, 4) 24680 return offset + 4 24681} 24682 24683Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { 24684 return writeFloat(this, value, offset, true, noAssert) 24685} 24686 24687Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { 24688 return writeFloat(this, value, offset, false, noAssert) 24689} 24690 24691function writeDouble (buf, value, offset, littleEndian, noAssert) { 24692 value = +value 24693 offset = offset >>> 0 24694 if (!noAssert) { 24695 checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) 24696 } 24697 ieee754.write(buf, value, offset, littleEndian, 52, 8) 24698 return offset + 8 24699} 24700 24701Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { 24702 return writeDouble(this, value, offset, true, noAssert) 24703} 24704 24705Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { 24706 return writeDouble(this, value, offset, false, noAssert) 24707} 24708 24709// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) 24710Buffer.prototype.copy = function copy (target, targetStart, start, end) { 24711 if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer') 24712 if (!start) start = 0 24713 if (!end && end !== 0) end = this.length 24714 if (targetStart >= target.length) targetStart = target.length 24715 if (!targetStart) targetStart = 0 24716 if (end > 0 && end < start) end = start 24717 24718 // Copy 0 bytes; we're done 24719 if (end === start) return 0 24720 if (target.length === 0 || this.length === 0) return 0 24721 24722 // Fatal error conditions 24723 if (targetStart < 0) { 24724 throw new RangeError('targetStart out of bounds') 24725 } 24726 if (start < 0 || start >= this.length) throw new RangeError('Index out of range') 24727 if (end < 0) throw new RangeError('sourceEnd out of bounds') 24728 24729 // Are we oob? 24730 if (end > this.length) end = this.length 24731 if (target.length - targetStart < end - start) { 24732 end = target.length - targetStart + start 24733 } 24734 24735 var len = end - start 24736 24737 if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') { 24738 // Use built-in when available, missing from IE11 24739 this.copyWithin(targetStart, start, end) 24740 } else { 24741 Uint8Array.prototype.set.call( 24742 target, 24743 this.subarray(start, end), 24744 targetStart 24745 ) 24746 } 24747 24748 return len 24749} 24750 24751// Usage: 24752// buffer.fill(number[, offset[, end]]) 24753// buffer.fill(buffer[, offset[, end]]) 24754// buffer.fill(string[, offset[, end]][, encoding]) 24755Buffer.prototype.fill = function fill (val, start, end, encoding) { 24756 // Handle string cases: 24757 if (typeof val === 'string') { 24758 if (typeof start === 'string') { 24759 encoding = start 24760 start = 0 24761 end = this.length 24762 } else if (typeof end === 'string') { 24763 encoding = end 24764 end = this.length 24765 } 24766 if (encoding !== undefined && typeof encoding !== 'string') { 24767 throw new TypeError('encoding must be a string') 24768 } 24769 if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { 24770 throw new TypeError('Unknown encoding: ' + encoding) 24771 } 24772 if (val.length === 1) { 24773 var code = val.charCodeAt(0) 24774 if ((encoding === 'utf8' && code < 128) || 24775 encoding === 'latin1') { 24776 // Fast path: If `val` fits into a single byte, use that numeric value. 24777 val = code 24778 } 24779 } 24780 } else if (typeof val === 'number') { 24781 val = val & 255 24782 } else if (typeof val === 'boolean') { 24783 val = Number(val) 24784 } 24785 24786 // Invalid ranges are not set to a default, so can range check early. 24787 if (start < 0 || this.length < start || this.length < end) { 24788 throw new RangeError('Out of range index') 24789 } 24790 24791 if (end <= start) { 24792 return this 24793 } 24794 24795 start = start >>> 0 24796 end = end === undefined ? this.length : end >>> 0 24797 24798 if (!val) val = 0 24799 24800 var i 24801 if (typeof val === 'number') { 24802 for (i = start; i < end; ++i) { 24803 this[i] = val 24804 } 24805 } else { 24806 var bytes = Buffer.isBuffer(val) 24807 ? val 24808 : Buffer.from(val, encoding) 24809 var len = bytes.length 24810 if (len === 0) { 24811 throw new TypeError('The value "' + val + 24812 '" is invalid for argument "value"') 24813 } 24814 for (i = 0; i < end - start; ++i) { 24815 this[i + start] = bytes[i % len] 24816 } 24817 } 24818 24819 return this 24820} 24821 24822// HELPER FUNCTIONS 24823// ================ 24824 24825var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g 24826 24827function base64clean (str) { 24828 // Node takes equal signs as end of the Base64 encoding 24829 str = str.split('=')[0] 24830 // Node strips out invalid characters like \n and \t from the string, base64-js does not 24831 str = str.trim().replace(INVALID_BASE64_RE, '') 24832 // Node converts strings with length < 2 to '' 24833 if (str.length < 2) return '' 24834 // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not 24835 while (str.length % 4 !== 0) { 24836 str = str + '=' 24837 } 24838 return str 24839} 24840 24841function utf8ToBytes (string, units) { 24842 units = units || Infinity 24843 var codePoint 24844 var length = string.length 24845 var leadSurrogate = null 24846 var bytes = [] 24847 24848 for (var i = 0; i < length; ++i) { 24849 codePoint = string.charCodeAt(i) 24850 24851 // is surrogate component 24852 if (codePoint > 0xD7FF && codePoint < 0xE000) { 24853 // last char was a lead 24854 if (!leadSurrogate) { 24855 // no lead yet 24856 if (codePoint > 0xDBFF) { 24857 // unexpected trail 24858 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 24859 continue 24860 } else if (i + 1 === length) { 24861 // unpaired lead 24862 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 24863 continue 24864 } 24865 24866 // valid lead 24867 leadSurrogate = codePoint 24868 24869 continue 24870 } 24871 24872 // 2 leads in a row 24873 if (codePoint < 0xDC00) { 24874 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 24875 leadSurrogate = codePoint 24876 continue 24877 } 24878 24879 // valid surrogate pair 24880 codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 24881 } else if (leadSurrogate) { 24882 // valid bmp char, but last char was a lead 24883 if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) 24884 } 24885 24886 leadSurrogate = null 24887 24888 // encode utf8 24889 if (codePoint < 0x80) { 24890 if ((units -= 1) < 0) break 24891 bytes.push(codePoint) 24892 } else if (codePoint < 0x800) { 24893 if ((units -= 2) < 0) break 24894 bytes.push( 24895 codePoint >> 0x6 | 0xC0, 24896 codePoint & 0x3F | 0x80 24897 ) 24898 } else if (codePoint < 0x10000) { 24899 if ((units -= 3) < 0) break 24900 bytes.push( 24901 codePoint >> 0xC | 0xE0, 24902 codePoint >> 0x6 & 0x3F | 0x80, 24903 codePoint & 0x3F | 0x80 24904 ) 24905 } else if (codePoint < 0x110000) { 24906 if ((units -= 4) < 0) break 24907 bytes.push( 24908 codePoint >> 0x12 | 0xF0, 24909 codePoint >> 0xC & 0x3F | 0x80, 24910 codePoint >> 0x6 & 0x3F | 0x80, 24911 codePoint & 0x3F | 0x80 24912 ) 24913 } else { 24914 throw new Error('Invalid code point') 24915 } 24916 } 24917 24918 return bytes 24919} 24920 24921function asciiToBytes (str) { 24922 var byteArray = [] 24923 for (var i = 0; i < str.length; ++i) { 24924 // Node's code seems to be doing this and not & 0x7F.. 24925 byteArray.push(str.charCodeAt(i) & 0xFF) 24926 } 24927 return byteArray 24928} 24929 24930function utf16leToBytes (str, units) { 24931 var c, hi, lo 24932 var byteArray = [] 24933 for (var i = 0; i < str.length; ++i) { 24934 if ((units -= 2) < 0) break 24935 24936 c = str.charCodeAt(i) 24937 hi = c >> 8 24938 lo = c % 256 24939 byteArray.push(lo) 24940 byteArray.push(hi) 24941 } 24942 24943 return byteArray 24944} 24945 24946function base64ToBytes (str) { 24947 return base64.toByteArray(base64clean(str)) 24948} 24949 24950function blitBuffer (src, dst, offset, length) { 24951 for (var i = 0; i < length; ++i) { 24952 if ((i + offset >= dst.length) || (i >= src.length)) break 24953 dst[i + offset] = src[i] 24954 } 24955 return i 24956} 24957 24958// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass 24959// the `instanceof` check but they should be treated as of that type. 24960// See: https://github.com/feross/buffer/issues/166 24961function isInstance (obj, type) { 24962 return obj instanceof type || 24963 (obj != null && obj.constructor != null && obj.constructor.name != null && 24964 obj.constructor.name === type.name) 24965} 24966function numberIsNaN (obj) { 24967 // For IE11 support 24968 return obj !== obj // eslint-disable-line no-self-compare 24969} 24970 24971// Create lookup table for `toString('hex')` 24972// See: https://github.com/feross/buffer/issues/219 24973var hexSliceLookupTable = (function () { 24974 var alphabet = '0123456789abcdef' 24975 var table = new Array(256) 24976 for (var i = 0; i < 16; ++i) { 24977 var i16 = i * 16 24978 for (var j = 0; j < 16; ++j) { 24979 table[i16 + j] = alphabet[i] + alphabet[j] 24980 } 24981 } 24982 return table 24983})() 24984 24985 24986/***/ }), 24987 24988/***/ "./node_modules/css-loader/dist/cjs.js??clonedRuleSet-8.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-8.use[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css": 24989/*!***********************************************************************************************************************************************************************************************************************************************************************************************************************************************************!*\ 24990 !*** ./node_modules/css-loader/dist/cjs.js??clonedRuleSet-8.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-8.use[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css ***! 24991 \***********************************************************************************************************************************************************************************************************************************************************************************************************************************************************/ 24992/***/ (function(module, __webpack_exports__, __webpack_require__) { 24993 24994"use strict"; 24995__webpack_require__.r(__webpack_exports__); 24996/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js"); 24997/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_0__); 24998// Imports 24999 25000var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_0___default()(function(i){return i[1]}); 25001// Module 25002___CSS_LOADER_EXPORT___.push([module.id, "\n.register[data-v-8fcbc800] {text-transform: uppercase; color:#cc0000;}\nbutton[data-v-8fcbc800] {\r\n padding-right: 15px;\r\n padding-left: 15px;\n}\n.form__show-password[data-v-8fcbc800] {\r\n position: absolute;\r\n top: 29px;\r\n right: 22px;\r\n width: 42px;\r\n height: 22px;\r\n border: 2px solid #eaeaea;\r\n border-radius: 22px;\r\n transition: background-color 0.15s ease;\n}\n.form__show-password[data-v-8fcbc800]::before {\r\n content: \"\";\r\n position: absolute;\r\n top: -2px;\r\n left: -2px;\r\n width: 22px;\r\n height: 22px;\r\n border-radius: 50%;\r\n background-color: #fff;\r\n box-shadow: 0 5px 10px rgb(0 0 0 / 13%);\r\n transition: transform 0.15s ease;\n}\n.form__show-password_active[data-v-8fcbc800] {\r\n background-color: #83a4d4;\n}\n.form__show-password_active[data-v-8fcbc800]::before {\r\n transform: translateX(20px);\n}\n.control-label[data-v-8fcbc800] {font-size: 0.74rem; font-weight:700; margin-bottom:4px;\n}\n.card-title[data-v-8fcbc800] {font-size:1.2rem;}\n.card-body[data-v-8fcbc800] { padding: 0.3rem !important;\n}\n.error[data-v-8fcbc800] { color: red; display:block; width:100%;\n}\n.login-type__btn[data-v-8fcbc800] { height: auto; padding: 0; margin: 0; border-bottom: 1px dashed; line-height: .9; background: #fff;}\nh4[data-v-8fcbc800] {width:100%; display:block;\n}\n.mb-2[data-v-8fcbc800] { margin-bottom: 0.5rem !important;\n}\n.mb-3[data-v-8fcbc800] { margin-bottom: 1rem !important;\n}\n.p-1[data-v-8fcbc800] { padding: 0.25rem !important;\n}\n.input-group[data-v-8fcbc800] {\r\n position: relative;\r\n display: flex;\r\n flex-wrap: wrap;\r\n align-items: stretch;\r\n width: 100%;\n}\n.input-group > .form-control[data-v-8fcbc800] {\r\n position: relative;\r\n flex: 1 1 auto;\r\n width: 1%;\r\n margin-bottom: 0;\n}\n.input-group > .form-control + .form-control[data-v-8fcbc800],\r\n .input-group > .form-control-plaintext + .form-control[data-v-8fcbc800],\r\n .input-group > .custom-select + .form-control[data-v-8fcbc800],\r\n .input-group > .custom-file + .form-control[data-v-8fcbc800] {\r\n margin-left: -1px;\n}\n.input-group > .form-control[data-v-8fcbc800]:focus {\r\n z-index: 3;\n}\n.input-group > .form-control[data-v-8fcbc800]:not(:last-child) {\r\n border-top-right-radius: 0;\r\n border-bottom-right-radius: 0;\n}\n.input-group > .form-control[data-v-8fcbc800]:not(:first-child) {\r\n border-top-left-radius: 0;\r\n border-bottom-left-radius: 0;\n}\n.input-group-prepend[data-v-8fcbc800] {\r\n display: flex;\n}\n.input-group-prepend .btn + .input-group-text[data-v-8fcbc800],\r\n .input-group-prepend .input-group-text + .input-group-text[data-v-8fcbc800],\r\n .input-group-append .btn + .btn[data-v-8fcbc800],\r\n .input-group-append .btn + .input-group-text[data-v-8fcbc800],\r\n .input-group-append .input-group-text + .input-group-text[data-v-8fcbc800],\r\n .input-group-append .input-group-text + .btn[data-v-8fcbc800] {\r\n margin-left: -1px;\n}\n.input-group-prepend[data-v-8fcbc800] {\r\n margin-right: -1px;\n}\n.input-group-text[data-v-8fcbc800] {\r\n display: flex;\r\n align-items: center;\r\n padding: 0.33rem 0.70rem;\r\n margin-bottom: 0;\r\n font-size: 1rem;\r\n font-weight: 400;\r\n line-height: 1.35;\r\n color: #495057;\r\n text-align: center;\r\n white-space: nowrap;\r\n background-color: #e9ecef;\r\n border: 1px solid #ced4da;\r\n border-radius: 0.25rem;\n}\n.code[data-v-8fcbc800] {width:32px; display:inline; margin-right:3px; padding-left:12px !important; padding-right:0 !important;}\r\n", ""]); 25003// Exports 25004/* harmony default export */ __webpack_exports__["default"] = (___CSS_LOADER_EXPORT___); 25005 25006 25007/***/ }), 25008
vendor: 1,877 bytes, lines 25009-25084
25009/***/ "./node_modules/css-loader/dist/runtime/api.js": 25010/*!*****************************************************!*\ 25011 !*** ./node_modules/css-loader/dist/runtime/api.js ***! 25012 \*****************************************************/ 25013/***/ (function(module) { 25014 25015"use strict"; 25016 25017 25018/* 25019 MIT License http://www.opensource.org/licenses/mit-license.php 25020 Author Tobias Koppers @sokra 25021*/ 25022// css base code, injected by the css-loader 25023// eslint-disable-next-line func-names 25024module.exports = function (cssWithMappingToString) { 25025 var list = []; // return the list of modules as css string 25026 25027 list.toString = function toString() { 25028 return this.map(function (item) { 25029 var content = cssWithMappingToString(item); 25030 25031 if (item[2]) { 25032 return "@media ".concat(item[2], " {").concat(content, "}"); 25033 } 25034 25035 return content; 25036 }).join(""); 25037 }; // import a list of modules into the list 25038 // eslint-disable-next-line func-names 25039 25040 25041 list.i = function (modules, mediaQuery, dedupe) { 25042 if (typeof modules === "string") { 25043 // eslint-disable-next-line no-param-reassign 25044 modules = [[null, modules, ""]]; 25045 } 25046 25047 var alreadyImportedModules = {}; 25048 25049 if (dedupe) { 25050 for (var i = 0; i < this.length; i++) { 25051 // eslint-disable-next-line prefer-destructuring 25052 var id = this[i][0]; 25053 25054 if (id != null) { 25055 alreadyImportedModules[id] = true; 25056 } 25057 } 25058 } 25059 25060 for (var _i = 0; _i < modules.length; _i++) { 25061 var item = [].concat(modules[_i]); 25062 25063 if (dedupe && alreadyImportedModules[item[0]]) { 25064 // eslint-disable-next-line no-continue 25065 continue; 25066 } 25067 25068 if (mediaQuery) { 25069 if (!item[2]) { 25070 item[2] = mediaQuery; 25071 } else { 25072 item[2] = "".concat(mediaQuery, " and ").concat(item[2]); 25073 } 25074 } 25075 25076 list.push(item); 25077 } 25078 }; 25079 25080 return list; 25081}; 25082 25083/***/ }), 25084
vendor: 2,395 bytes, lines 25085-25179
25085/***/ "./node_modules/ieee754/index.js": 25086/*!***************************************!*\ 25087 !*** ./node_modules/ieee754/index.js ***! 25088 \***************************************/ 25089/***/ (function(__unused_webpack_module, exports) { 25090 25091/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */ 25092exports.read = function (buffer, offset, isLE, mLen, nBytes) { 25093 var e, m 25094 var eLen = (nBytes * 8) - mLen - 1 25095 var eMax = (1 << eLen) - 1 25096 var eBias = eMax >> 1 25097 var nBits = -7 25098 var i = isLE ? (nBytes - 1) : 0 25099 var d = isLE ? -1 : 1 25100 var s = buffer[offset + i] 25101 25102 i += d 25103 25104 e = s & ((1 << (-nBits)) - 1) 25105 s >>= (-nBits) 25106 nBits += eLen 25107 for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {} 25108 25109 m = e & ((1 << (-nBits)) - 1) 25110 e >>= (-nBits) 25111 nBits += mLen 25112 for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {} 25113 25114 if (e === 0) { 25115 e = 1 - eBias 25116 } else if (e === eMax) { 25117 return m ? NaN : ((s ? -1 : 1) * Infinity) 25118 } else { 25119 m = m + Math.pow(2, mLen) 25120 e = e - eBias 25121 } 25122 return (s ? -1 : 1) * m * Math.pow(2, e - mLen) 25123} 25124 25125exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { 25126 var e, m, c 25127 var eLen = (nBytes * 8) - mLen - 1 25128 var eMax = (1 << eLen) - 1 25129 var eBias = eMax >> 1 25130 var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) 25131 var i = isLE ? 0 : (nBytes - 1) 25132 var d = isLE ? 1 : -1 25133 var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 25134 25135 value = Math.abs(value) 25136 25137 if (isNaN(value) || value === Infinity) { 25138 m = isNaN(value) ? 1 : 0 25139 e = eMax 25140 } else { 25141 e = Math.floor(Math.log(value) / Math.LN2) 25142 if (value * (c = Math.pow(2, -e)) < 1) { 25143 e-- 25144 c *= 2 25145 } 25146 if (e + eBias >= 1) { 25147 value += rt / c 25148 } else { 25149 value += rt * Math.pow(2, 1 - eBias) 25150 } 25151 if (value * c >= 2) { 25152 e++ 25153 c /= 2 25154 } 25155 25156 if (e + eBias >= eMax) { 25157 m = 0 25158 e = eMax 25159 } else if (e + eBias >= 1) { 25160 m = ((value * c) - 1) * Math.pow(2, mLen) 25161 e = e + eBias 25162 } else { 25163 m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) 25164 e = 0 25165 } 25166 } 25167 25168 for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} 25169 25170 e = (e << mLen) | m 25171 eLen += mLen 25172 for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} 25173 25174 buffer[offset + i - d] |= s * 128 25175} 25176 25177 25178/***/ }), 25179
vendor: 196,579 bytes, lines 25180-28216
25180/***/ "./node_modules/inputmask/dist/inputmask.js": 25181/*!**************************************************!*\ 25182 !*** ./node_modules/inputmask/dist/inputmask.js ***! 25183 \**************************************************/ 25184/***/ (function(module) { 25185 25186/*! 25187 * dist/inputmask 25188 * https://github.com/RobinHerbots/Inputmask 25189 * Copyright (c) 2010 - 2021 Robin Herbots 25190 * Licensed under the MIT license 25191 * Version: 5.0.7 25192 */ 25193!function(e, t) { 25194 if (true) module.exports = t(); else { var a, i; } 25195}(self, (function() { 25196 return function() { 25197 "use strict"; 25198 var e = { 25199 8741: function(e, t) { 25200 Object.defineProperty(t, "__esModule", { 25201 value: !0 25202 }), t.default = void 0; 25203 var i = !("undefined" == typeof window || !window.document || !window.document.createElement); 25204 t.default = i; 25205 }, 25206 3976: function(e, t, i) { 25207 Object.defineProperty(t, "__esModule", { 25208 value: !0 25209 }), t.default = void 0; 25210 var a, n = (a = i(5581)) && a.__esModule ? a : { 25211 default: a 25212 }; 25213 var r = { 25214 _maxTestPos: 500, 25215 placeholder: "_", 25216 optionalmarker: [ "[", "]" ], 25217 quantifiermarker: [ "{", "}" ], 25218 groupmarker: [ "(", ")" ], 25219 alternatormarker: "|", 25220 escapeChar: "\\", 25221 mask: null, 25222 regex: null, 25223 oncomplete: function() {}, 25224 onincomplete: function() {}, 25225 oncleared: function() {}, 25226 repeat: 0, 25227 greedy: !1, 25228 autoUnmask: !1, 25229 removeMaskOnSubmit: !1, 25230 clearMaskOnLostFocus: !0, 25231 insertMode: !0, 25232 insertModeVisual: !0, 25233 clearIncomplete: !1, 25234 alias: null, 25235 onKeyDown: function() {}, 25236 onBeforeMask: null, 25237 onBeforePaste: function(e, t) { 25238 return "function" == typeof t.onBeforeMask ? t.onBeforeMask.call(this, e, t) : e; 25239 }, 25240 onBeforeWrite: null, 25241 onUnMask: null, 25242 showMaskOnFocus: !0, 25243 showMaskOnHover: !0, 25244 onKeyValidation: function() {}, 25245 skipOptionalPartCharacter: " ", 25246 numericInput: !1, 25247 rightAlign: !1, 25248 undoOnEscape: !0, 25249 radixPoint: "", 25250 _radixDance: !1, 25251 groupSeparator: "", 25252 keepStatic: null, 25253 positionCaretOnTab: !0, 25254 tabThrough: !1, 25255 supportsInputType: [ "text", "tel", "url", "password", "search" ], 25256 ignorables: [ n.default.BACKSPACE, n.default.TAB, n.default["PAUSE/BREAK"], n.default.ESCAPE, n.default.PAGE_UP, n.default.PAGE_DOWN, n.default.END, n.default.HOME, n.default.LEFT, n.default.UP, n.default.RIGHT, n.default.DOWN, n.default.INSERT, n.default.DELETE, 93, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 0, 229 ], 25257 isComplete: null, 25258 preValidation: null, 25259 postValidation: null, 25260 staticDefinitionSymbol: void 0, 25261 jitMasking: !1, 25262 nullable: !0, 25263 inputEventOnly: !1, 25264 noValuePatching: !1, 25265 positionCaretOnClick: "lvp", 25266 casing: null, 25267 inputmode: "text", 25268 importDataAttributes: !0, 25269 shiftPositions: !0, 25270 usePrototypeDefinitions: !0, 25271 validationEventTimeOut: 3e3, 25272 substitutes: {} 25273 }; 25274 t.default = r; 25275 }, 25276 7392: function(e, t) { 25277 Object.defineProperty(t, "__esModule", { 25278 value: !0 25279 }), t.default = void 0; 25280 t.default = { 25281 9: { 25282 validator: "[0-9\uff10-\uff19]", 25283 definitionSymbol: "*" 25284 }, 25285 a: { 25286 validator: "[A-Za-z\u0410-\u044f\u0401\u0451\xc0-\xff\xb5]", 25287 definitionSymbol: "*" 25288 }, 25289 "*": { 25290 validator: "[0-9\uff10-\uff19A-Za-z\u0410-\u044f\u0401\u0451\xc0-\xff\xb5]" 25291 } 25292 }; 25293 }, 25294 253: function(e, t) { 25295 Object.defineProperty(t, "__esModule", { 25296 value: !0 25297 }), t.default = function(e, t, i) { 25298 if (void 0 === i) return e.__data ? e.__data[t] : null; 25299 e.__data = e.__data || {}, e.__data[t] = i; 25300 }; 25301 }, 25302 3776: function(e, t, i) { 25303 Object.defineProperty(t, "__esModule", { 25304 value: !0 25305 }), t.Event = void 0, t.off = function(e, t) { 25306 var i, a; 25307 function n(e, t, n) { 25308 if (e in i == !0) if (a.removeEventListener ? a.removeEventListener(e, n, !1) : a.detachEvent && a.detachEvent("on" + e, n), 25309 "global" === t) for (var r in i[e]) i[e][r].splice(i[e][r].indexOf(n), 1); else i[e][t].splice(i[e][t].indexOf(n), 1); 25310 } 25311 function r(e, a) { 25312 var n, r, o = []; 25313 if (e.length > 0) if (void 0 === t) for (n = 0, r = i[e][a].length; n < r; n++) o.push({ 25314 ev: e, 25315 namespace: a && a.length > 0 ? a : "global", 25316 handler: i[e][a][n] 25317 }); else o.push({ 25318 ev: e, 25319 namespace: a && a.length > 0 ? a : "global", 25320 handler: t 25321 }); else if (a.length > 0) for (var l in i) for (var s in i[l]) if (s === a) if (void 0 === t) for (n = 0, 25322 r = i[l][s].length; n < r; n++) o.push({ 25323 ev: l, 25324 namespace: s, 25325 handler: i[l][s][n] 25326 }); else o.push({ 25327 ev: l, 25328 namespace: s, 25329 handler: t 25330 }); 25331 return o; 25332 } 25333 if (u(this[0]) && e) { 25334 i = this[0].eventRegistry, a = this[0]; 25335 for (var o = e.split(" "), l = 0; l < o.length; l++) for (var s = o[l].split("."), c = r(s[0], s[1]), f = 0, d = c.length; f < d; f++) n(c[f].ev, c[f].namespace, c[f].handler); 25336 } 25337 return this; 25338 }, t.on = function(e, t) { 25339 function i(e, i) { 25340 n.addEventListener ? n.addEventListener(e, t, !1) : n.attachEvent && n.attachEvent("on" + e, t), 25341 a[e] = a[e] || {}, a[e][i] = a[e][i] || [], a[e][i].push(t); 25342 } 25343 if (u(this[0])) for (var a = this[0].eventRegistry, n = this[0], r = e.split(" "), o = 0; o < r.length; o++) { 25344 var l = r[o].split("."), s = l[0], c = l[1] || "global"; 25345 i(s, c); 25346 } 25347 return this; 25348 }, t.trigger = function(e) { 25349 if (u(this[0])) for (var t = this[0].eventRegistry, i = this[0], a = "string" == typeof e ? e.split(" ") : [ e.type ], r = 0; r < a.length; r++) { 25350 var l = a[r].split("."), s = l[0], c = l[1] || "global"; 25351 if (void 0 !== document && "global" === c) { 25352 var f, d, p = { 25353 bubbles: !0, 25354 cancelable: !0, 25355 detail: arguments[1] 25356 }; 25357 if (document.createEvent) { 25358 try { 25359 if ("input" === s) p.inputType = "insertText", f = new InputEvent(s, p); else f = new CustomEvent(s, p); 25360 } catch (e) { 25361 (f = document.createEvent("CustomEvent")).initCustomEvent(s, p.bubbles, p.cancelable, p.detail); 25362 } 25363 e.type && (0, n.default)(f, e), i.dispatchEvent(f); 25364 } else (f = document.createEventObject()).eventType = s, f.detail = arguments[1], 25365 e.type && (0, n.default)(f, e), i.fireEvent("on" + f.eventType, f); 25366 } else if (void 0 !== t[s]) if (arguments[0] = arguments[0].type ? arguments[0] : o.default.Event(arguments[0]), 25367 arguments[0].detail = arguments.slice(1), "global" === c) for (var h in t[s]) for (d = 0; d < t[s][h].length; d++) t[s][h][d].apply(i, arguments); else for (d = 0; d < t[s][c].length; d++) t[s][c][d].apply(i, arguments); 25368 } 25369 return this; 25370 }; 25371 var a, n = s(i(600)), r = s(i(9380)), o = s(i(4963)), l = s(i(8741)); 25372 function s(e) { 25373 return e && e.__esModule ? e : { 25374 default: e 25375 }; 25376 } 25377 function u(e) { 25378 return e instanceof Element; 25379 } 25380 t.Event = a, "function" == typeof r.default.CustomEvent ? t.Event = a = r.default.CustomEvent : l.default && (t.Event = a = function(e, t) { 25381 t = t || { 25382 bubbles: !1, 25383 cancelable: !1, 25384 detail: void 0 25385 }; 25386 var i = document.createEvent("CustomEvent"); 25387 return i.initCustomEvent(e, t.bubbles, t.cancelable, t.detail), i; 25388 }, a.prototype = r.default.Event.prototype); 25389 }, 25390 600: function(e, t) { 25391 function i(e) { 25392 return i = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) { 25393 return typeof e; 25394 } : function(e) { 25395 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e; 25396 }, i(e); 25397 } 25398 Object.defineProperty(t, "__esModule", { 25399 value: !0 25400 }), t.default = function e() { 25401 var t, a, n, r, o, l, s = arguments[0] || {}, u = 1, c = arguments.length, f = !1; 25402 "boolean" == typeof s && (f = s, s = arguments[u] || {}, u++); 25403 "object" !== i(s) && "function" != typeof s && (s = {}); 25404 for (;u < c; u++) if (null != (t = arguments[u])) for (a in t) n = s[a], r = t[a], 25405 s !== r && (f && r && ("[object Object]" === Object.prototype.toString.call(r) || (o = Array.isArray(r))) ? (o ? (o = !1, 25406 l = n && Array.isArray(n) ? n : []) : l = n && "[object Object]" === Object.prototype.toString.call(n) ? n : {}, 25407 s[a] = e(f, l, r)) : void 0 !== r && (s[a] = r)); 25408 return s; 25409 }; 25410 }, 25411 4963: function(e, t, i) { 25412 Object.defineProperty(t, "__esModule", { 25413 value: !0 25414 }), t.default = void 0; 25415 var a = l(i(600)), n = l(i(9380)), r = l(i(253)), o = i(3776); 25416 function l(e) { 25417 return e && e.__esModule ? e : { 25418 default: e 25419 }; 25420 } 25421 var s = n.default.document; 25422 function u(e) { 25423 return e instanceof u ? e : this instanceof u ? void (null != e && e !== n.default && (this[0] = e.nodeName ? e : void 0 !== e[0] && e[0].nodeName ? e[0] : s.querySelector(e), 25424 void 0 !== this[0] && null !== this[0] && (this[0].eventRegistry = this[0].eventRegistry || {}))) : new u(e); 25425 } 25426 u.prototype = { 25427 on: o.on, 25428 off: o.off, 25429 trigger: o.trigger 25430 }, u.extend = a.default, u.data = r.default, u.Event = o.Event; 25431 var c = u; 25432 t.default = c; 25433 }, 25434 9845: function(e, t, i) { 25435 Object.defineProperty(t, "__esModule", { 25436 value: !0 25437 }), t.ua = t.mobile = t.iphone = t.iemobile = t.ie = void 0; 25438 var a, n = (a = i(9380)) && a.__esModule ? a : { 25439 default: a 25440 }; 25441 var r = n.default.navigator && n.default.navigator.userAgent || "", o = r.indexOf("MSIE ") > 0 || r.indexOf("Trident/") > 0, l = "ontouchstart" in n.default, s = /iemobile/i.test(r), u = /iphone/i.test(r) && !s; 25442 t.iphone = u, t.iemobile = s, t.mobile = l, t.ie = o, t.ua = r; 25443 }, 25444 7184: function(e, t) { 25445 Object.defineProperty(t, "__esModule", { 25446 value: !0 25447 }), t.default = function(e) { 25448 return e.replace(i, "\\$1"); 25449 }; 25450 var i = new RegExp("(\\" + [ "/", ".", "*", "+", "?", "|", "(", ")", "[", "]", "{", "}", "\\", "$", "^" ].join("|\\") + ")", "gim"); 25451 }, 25452 6030: function(e, t, i) { 25453 Object.defineProperty(t, "__esModule", { 25454 value: !0 25455 }), t.EventHandlers = void 0; 25456 var a, n = i(8711), r = (a = i(5581)) && a.__esModule ? a : { 25457 default: a 25458 }, o = i(9845), l = i(7215), s = i(7760), u = i(4713); 25459 function c(e, t) { 25460 var i = "undefined" != typeof Symbol && e[Symbol.iterator] || e["@@iterator"]; 25461 if (!i) { 25462 if (Array.isArray(e) || (i = function(e, t) { 25463 if (!e) return; 25464 if ("string" == typeof e) return f(e, t); 25465 var i = Object.prototype.toString.call(e).slice(8, -1); 25466 "Object" === i && e.constructor && (i = e.constructor.name); 25467 if ("Map" === i || "Set" === i) return Array.from(e); 25468 if ("Arguments" === i || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(i)) return f(e, t); 25469 }(e)) || t && e && "number" == typeof e.length) { 25470 i && (e = i); 25471 var a = 0, n = function() {}; 25472 return { 25473 s: n, 25474 n: function() { 25475 return a >= e.length ? { 25476 done: !0 25477 } : { 25478 done: !1, 25479 value: e[a++] 25480 }; 25481 }, 25482 e: function(e) { 25483 throw e; 25484 }, 25485 f: n 25486 }; 25487 } 25488 throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 25489 } 25490 var r, o = !0, l = !1; 25491 return { 25492 s: function() { 25493 i = i.call(e); 25494 }, 25495 n: function() { 25496 var e = i.next(); 25497 return o = e.done, e; 25498 }, 25499 e: function(e) { 25500 l = !0, r = e; 25501 }, 25502 f: function() { 25503 try { 25504 o || null == i.return || i.return(); 25505 } finally { 25506 if (l) throw r; 25507 } 25508 } 25509 }; 25510 } 25511 function f(e, t) { 25512 (null == t || t > e.length) && (t = e.length); 25513 for (var i = 0, a = new Array(t); i < t; i++) a[i] = e[i]; 25514 return a; 25515 } 25516 var d = { 25517 keydownEvent: function(e) { 25518 var t = this.inputmask, i = t.opts, a = t.dependencyLib, c = t.maskset, f = this, d = a(f), p = e.keyCode, h = n.caret.call(t, f), v = i.onKeyDown.call(this, e, n.getBuffer.call(t), h, i); 25519 if (void 0 !== v) return v; 25520 if (p === r.default.BACKSPACE || p === r.default.DELETE || o.iphone && p === r.default.BACKSPACE_SAFARI || e.ctrlKey && p === r.default.X && !("oncut" in f)) e.preventDefault(), 25521 l.handleRemove.call(t, f, p, h), (0, s.writeBuffer)(f, n.getBuffer.call(t, !0), c.p, e, f.inputmask._valueGet() !== n.getBuffer.call(t).join("")); else if (p === r.default.END || p === r.default.PAGE_DOWN) { 25522 e.preventDefault(); 25523 var m = n.seekNext.call(t, n.getLastValidPosition.call(t)); 25524 n.caret.call(t, f, e.shiftKey ? h.begin : m, m, !0); 25525 } else p === r.default.HOME && !e.shiftKey || p === r.default.PAGE_UP ? (e.preventDefault(), 25526 n.caret.call(t, f, 0, e.shiftKey ? h.begin : 0, !0)) : i.undoOnEscape && p === r.default.ESCAPE && !0 !== e.altKey ? ((0, 25527 s.checkVal)(f, !0, !1, t.undoValue.split("")), d.trigger("click")) : p !== r.default.INSERT || e.shiftKey || e.ctrlKey || void 0 !== t.userOptions.insertMode ? !0 === i.tabThrough && p === r.default.TAB ? !0 === e.shiftKey ? (h.end = n.seekPrevious.call(t, h.end, !0), 25528 !0 === u.getTest.call(t, h.end - 1).match.static && h.end--, h.begin = n.seekPrevious.call(t, h.end, !0), 25529 h.begin >= 0 && h.end > 0 && (e.preventDefault(), n.caret.call(t, f, h.begin, h.end))) : (h.begin = n.seekNext.call(t, h.begin, !0), 25530 h.end = n.seekNext.call(t, h.begin, !0), h.end < c.maskLength && h.end--, h.begin <= c.maskLength && (e.preventDefault(), 25531 n.caret.call(t, f, h.begin, h.end))) : e.shiftKey || i.insertModeVisual && !1 === i.insertMode && (p === r.default.RIGHT ? setTimeout((function() { 25532 var e = n.caret.call(t, f); 25533 n.caret.call(t, f, e.begin); 25534 }), 0) : p === r.default.LEFT && setTimeout((function() { 25535 var e = n.translatePosition.call(t, f.inputmask.caretPos.begin); 25536 n.translatePosition.call(t, f.inputmask.caretPos.end); 25537 t.isRTL ? n.caret.call(t, f, e + (e === c.maskLength ? 0 : 1)) : n.caret.call(t, f, e - (0 === e ? 0 : 1)); 25538 }), 0)) : l.isSelection.call(t, h) ? i.insertMode = !i.insertMode : (i.insertMode = !i.insertMode, 25539 n.caret.call(t, f, h.begin, h.begin)); 25540 t.ignorable = i.ignorables.includes(p); 25541 }, 25542 keypressEvent: function(e, t, i, a, o) { 25543 var u = this.inputmask || this, c = u.opts, f = u.dependencyLib, d = u.maskset, p = u.el, h = f(p), v = e.keyCode; 25544 if (!(!0 === t || e.ctrlKey && e.altKey) && (e.ctrlKey || e.metaKey || u.ignorable)) return v === r.default.ENTER && u.undoValue !== u._valueGet(!0) && (u.undoValue = u._valueGet(!0), 25545 setTimeout((function() { 25546 h.trigger("change"); 25547 }), 0)), u.skipInputEvent = !0, !0; 25548 if (v) { 25549 44 !== v && 46 !== v || 3 !== e.location || "" === c.radixPoint || (v = c.radixPoint.charCodeAt(0)); 25550 var m, g = t ? { 25551 begin: o, 25552 end: o 25553 } : n.caret.call(u, p), k = String.fromCharCode(v); 25554 k = c.substitutes[k] || k, d.writeOutBuffer = !0; 25555 var y = l.isValid.call(u, g, k, a, void 0, void 0, void 0, t); 25556 if (!1 !== y && (n.resetMaskSet.call(u, !0), m = void 0 !== y.caret ? y.caret : n.seekNext.call(u, y.pos.begin ? y.pos.begin : y.pos), 25557 d.p = m), m = c.numericInput && void 0 === y.caret ? n.seekPrevious.call(u, m) : m, 25558 !1 !== i && (setTimeout((function() { 25559 c.onKeyValidation.call(p, v, y); 25560 }), 0), d.writeOutBuffer && !1 !== y)) { 25561 var b = n.getBuffer.call(u); 25562 (0, s.writeBuffer)(p, b, m, e, !0 !== t); 25563 } 25564 if (e.preventDefault(), t) return !1 !== y && (y.forwardPosition = m), y; 25565 } 25566 }, 25567 keyupEvent: function(e) { 25568 var t = this.inputmask; 25569 !t.isComposing || e.keyCode !== r.default.KEY_229 && e.keyCode !== r.default.ENTER || t.$el.trigger("input"); 25570 }, 25571 pasteEvent: function(e) { 25572 var t, i = this.inputmask, a = i.opts, r = i._valueGet(!0), o = n.caret.call(i, this); 25573 i.isRTL && (t = o.end, o.end = n.translatePosition.call(i, o.begin), o.begin = n.translatePosition.call(i, t)); 25574 var l = r.substr(0, o.begin), u = r.substr(o.end, r.length); 25575 if (l == (i.isRTL ? n.getBufferTemplate.call(i).slice().reverse() : n.getBufferTemplate.call(i)).slice(0, o.begin).join("") && (l = ""), 25576 u == (i.isRTL ? n.getBufferTemplate.call(i).slice().reverse() : n.getBufferTemplate.call(i)).slice(o.end).join("") && (u = ""), 25577 window.clipboardData && window.clipboardData.getData) r = l + window.clipboardData.getData("Text") + u; else { 25578 if (!e.clipboardData || !e.clipboardData.getData) return !0; 25579 r = l + e.clipboardData.getData("text/plain") + u; 25580 } 25581 var f = r; 25582 if (i.isRTL) { 25583 f = f.split(""); 25584 var d, p = c(n.getBufferTemplate.call(i)); 25585 try { 25586 for (p.s(); !(d = p.n()).done; ) { 25587 var h = d.value; 25588 f[0] === h && f.shift(); 25589 } 25590 } catch (e) { 25591 p.e(e); 25592 } finally { 25593 p.f(); 25594 } 25595 f = f.join(""); 25596 } 25597 if ("function" == typeof a.onBeforePaste) { 25598 if (!1 === (f = a.onBeforePaste.call(i, f, a))) return !1; 25599 f || (f = r); 25600 } 25601 (0, s.checkVal)(this, !0, !1, f.toString().split(""), e), e.preventDefault(); 25602 }, 25603 inputFallBackEvent: function(e) { 25604 var t = this.inputmask, i = t.opts, a = t.dependencyLib; 25605 var l = this, c = l.inputmask._valueGet(!0), f = (t.isRTL ? n.getBuffer.call(t).slice().reverse() : n.getBuffer.call(t)).join(""), p = n.caret.call(t, l, void 0, void 0, !0); 25606 if (f !== c) { 25607 c = function(e, i, a) { 25608 if (o.iemobile) { 25609 var r = i.replace(n.getBuffer.call(t).join(""), ""); 25610 if (1 === r.length) { 25611 var l = i.split(""); 25612 l.splice(a.begin, 0, r), i = l.join(""); 25613 } 25614 } 25615 return i; 25616 }(0, c, p); 25617 var h = function(e, a, r) { 25618 for (var o, l, s, c = e.substr(0, r.begin).split(""), f = e.substr(r.begin).split(""), d = a.substr(0, r.begin).split(""), p = a.substr(r.begin).split(""), h = c.length >= d.length ? c.length : d.length, v = f.length >= p.length ? f.length : p.length, m = "", g = [], k = "~"; c.length < h; ) c.push(k); 25619 for (;d.length < h; ) d.push(k); 25620 for (;f.length < v; ) f.unshift(k); 25621 for (;p.length < v; ) p.unshift(k); 25622 var y = c.concat(f), b = d.concat(p); 25623 for (l = 0, o = y.length; l < o; l++) switch (s = u.getPlaceholder.call(t, n.translatePosition.call(t, l)), 25624 m) { 25625 case "insertText": 25626 b[l - 1] === y[l] && r.begin == y.length - 1 && g.push(y[l]), l = o; 25627 break; 25628 25629 case "insertReplacementText": 25630 case "deleteContentBackward": 25631 y[l] === k ? r.end++ : l = o; 25632 break; 25633 25634 default: 25635 y[l] !== b[l] && (y[l + 1] !== k && y[l + 1] !== s && void 0 !== y[l + 1] || (b[l] !== s || b[l + 1] !== k) && b[l] !== k ? b[l + 1] === k && b[l] === y[l + 1] ? (m = "insertText", 25636 g.push(y[l]), r.begin--, r.end--) : y[l] !== s && y[l] !== k && (y[l + 1] === k || b[l] !== y[l] && b[l + 1] === y[l + 1]) ? (m = "insertReplacementText", 25637 g.push(y[l]), r.begin--) : y[l] === k ? (m = "deleteContentBackward", (n.isMask.call(t, n.translatePosition.call(t, l), !0) || b[l] === i.radixPoint) && r.end++) : l = o : (m = "insertText", 25638 g.push(y[l]), r.begin--, r.end--)); 25639 } 25640 return { 25641 action: m, 25642 data: g, 25643 caret: r 25644 }; 25645 }(c, f, p); 25646 switch ((l.inputmask.shadowRoot || l.ownerDocument).activeElement !== l && l.focus(), 25647 (0, s.writeBuffer)(l, n.getBuffer.call(t)), n.caret.call(t, l, p.begin, p.end, !0), 25648 h.action) { 25649 case "insertText": 25650 case "insertReplacementText": 25651 h.data.forEach((function(e, i) { 25652 var n = new a.Event("keypress"); 25653 n.keyCode = e.charCodeAt(0), t.ignorable = !1, d.keypressEvent.call(l, n); 25654 })), setTimeout((function() { 25655 t.$el.trigger("keyup"); 25656 }), 0); 25657 break; 25658 25659 case "deleteContentBackward": 25660 var v = new a.Event("keydown"); 25661 v.keyCode = r.default.BACKSPACE, d.keydownEvent.call(l, v); 25662 break; 25663 25664 default: 25665 (0, s.applyInputValue)(l, c); 25666 } 25667 e.preventDefault(); 25668 } 25669 }, 25670 compositionendEvent: function(e) { 25671 var t = this.inputmask; 25672 t.isComposing = !1, t.$el.trigger("input"); 25673 }, 25674 setValueEvent: function(e) { 25675 var t = this.inputmask, i = this, a = e && e.detail ? e.detail[0] : arguments[1]; 25676 void 0 === a && (a = i.inputmask._valueGet(!0)), (0, s.applyInputValue)(i, a), (e.detail && void 0 !== e.detail[1] || void 0 !== arguments[2]) && n.caret.call(t, i, e.detail ? e.detail[1] : arguments[2]); 25677 }, 25678 focusEvent: function(e) { 25679 var t = this.inputmask, i = t.opts, a = this, r = a.inputmask._valueGet(); 25680 i.showMaskOnFocus && r !== n.getBuffer.call(t).join("") && (0, s.writeBuffer)(a, n.getBuffer.call(t), n.seekNext.call(t, n.getLastValidPosition.call(t))), 25681 !0 !== i.positionCaretOnTab || !1 !== t.mouseEnter || l.isComplete.call(t, n.getBuffer.call(t)) && -1 !== n.getLastValidPosition.call(t) || d.clickEvent.apply(a, [ e, !0 ]), 25682 t.undoValue = t._valueGet(!0); 25683 }, 25684 invalidEvent: function(e) { 25685 this.inputmask.validationEvent = !0; 25686 }, 25687 mouseleaveEvent: function() { 25688 var e = this.inputmask, t = e.opts, i = this; 25689 e.mouseEnter = !1, t.clearMaskOnLostFocus && (i.inputmask.shadowRoot || i.ownerDocument).activeElement !== i && (0, 25690 s.HandleNativePlaceholder)(i, e.originalPlaceholder); 25691 }, 25692 clickEvent: function(e, t) { 25693 var i = this.inputmask, a = this; 25694 if ((a.inputmask.shadowRoot || a.ownerDocument).activeElement === a) { 25695 var r = n.determineNewCaretPosition.call(i, n.caret.call(i, a), t); 25696 void 0 !== r && n.caret.call(i, a, r); 25697 } 25698 }, 25699 cutEvent: function(e) { 25700 var t = this.inputmask, i = t.maskset, a = this, o = n.caret.call(t, a), u = t.isRTL ? n.getBuffer.call(t).slice(o.end, o.begin) : n.getBuffer.call(t).slice(o.begin, o.end), c = t.isRTL ? u.reverse().join("") : u.join(""); 25701 window.navigator.clipboard ? window.navigator.clipboard.writeText(c) : window.clipboardData && window.clipboardData.getData && window.clipboardData.setData("Text", c), 25702 l.handleRemove.call(t, a, r.default.DELETE, o), (0, s.writeBuffer)(a, n.getBuffer.call(t), i.p, e, t.undoValue !== t._valueGet(!0)); 25703 }, 25704 blurEvent: function(e) { 25705 var t = this.inputmask, i = t.opts, a = (0, t.dependencyLib)(this), r = this; 25706 if (r.inputmask) { 25707 (0, s.HandleNativePlaceholder)(r, t.originalPlaceholder); 25708 var o = r.inputmask._valueGet(), u = n.getBuffer.call(t).slice(); 25709 "" !== o && (i.clearMaskOnLostFocus && (-1 === n.getLastValidPosition.call(t) && o === n.getBufferTemplate.call(t).join("") ? u = [] : s.clearOptionalTail.call(t, u)), 25710 !1 === l.isComplete.call(t, u) && (setTimeout((function() { 25711 a.trigger("incomplete"); 25712 }), 0), i.clearIncomplete && (n.resetMaskSet.call(t), u = i.clearMaskOnLostFocus ? [] : n.getBufferTemplate.call(t).slice())), 25713 (0, s.writeBuffer)(r, u, void 0, e)), t.undoValue !== t._valueGet(!0) && (t.undoValue = t._valueGet(!0), 25714 a.trigger("change")); 25715 } 25716 }, 25717 mouseenterEvent: function() { 25718 var e = this.inputmask, t = e.opts, i = this; 25719 if (e.mouseEnter = !0, (i.inputmask.shadowRoot || i.ownerDocument).activeElement !== i) { 25720 var a = (e.isRTL ? n.getBufferTemplate.call(e).slice().reverse() : n.getBufferTemplate.call(e)).join(""); 25721 e.placeholder !== a && i.placeholder !== e.originalPlaceholder && (e.originalPlaceholder = i.placeholder), 25722 t.showMaskOnHover && (0, s.HandleNativePlaceholder)(i, a); 25723 } 25724 }, 25725 submitEvent: function() { 25726 var e = this.inputmask, t = e.opts; 25727 e.undoValue !== e._valueGet(!0) && e.$el.trigger("change"), -1 === n.getLastValidPosition.call(e) && e._valueGet && e._valueGet() === n.getBufferTemplate.call(e).join("") && e._valueSet(""), 25728 t.clearIncomplete && !1 === l.isComplete.call(e, n.getBuffer.call(e)) && e._valueSet(""), 25729 t.removeMaskOnSubmit && (e._valueSet(e.unmaskedvalue(), !0), setTimeout((function() { 25730 (0, s.writeBuffer)(e.el, n.getBuffer.call(e)); 25731 }), 0)); 25732 }, 25733 resetEvent: function() { 25734 var e = this.inputmask; 25735 e.refreshValue = !0, setTimeout((function() { 25736 (0, s.applyInputValue)(e.el, e._valueGet(!0)); 25737 }), 0); 25738 } 25739 }; 25740 t.EventHandlers = d; 25741 }, 25742 9716: function(e, t, i) { 25743 Object.defineProperty(t, "__esModule", { 25744 value: !0 25745 }), t.EventRuler = void 0; 25746 var a = l(i(2394)), n = l(i(5581)), r = i(8711), o = i(7760); 25747 function l(e) { 25748 return e && e.__esModule ? e : { 25749 default: e 25750 }; 25751 } 25752 var s = { 25753 on: function(e, t, i) { 25754 var l = e.inputmask.dependencyLib, s = function(t) { 25755 t.originalEvent && (t = t.originalEvent || t, arguments[0] = t); 25756 var s, u = this, c = u.inputmask, f = c ? c.opts : void 0; 25757 if (void 0 === c && "FORM" !== this.nodeName) { 25758 var d = l.data(u, "_inputmask_opts"); 25759 l(u).off(), d && new a.default(d).mask(u); 25760 } else { 25761 if ([ "submit", "reset", "setvalue" ].includes(t.type) || "FORM" === this.nodeName || !(u.disabled || u.readOnly && !("keydown" === t.type && t.ctrlKey && 67 === t.keyCode || !1 === f.tabThrough && t.keyCode === n.default.TAB))) { 25762 switch (t.type) { 25763 case "input": 25764 if (!0 === c.skipInputEvent || t.inputType && "insertCompositionText" === t.inputType) return c.skipInputEvent = !1, 25765 t.preventDefault(); 25766 break; 25767 25768 case "keydown": 25769 c.skipKeyPressEvent = !1, c.skipInputEvent = c.isComposing = t.keyCode === n.default.KEY_229; 25770 break; 25771 25772 case "keyup": 25773 case "compositionend": 25774 c.isComposing && (c.skipInputEvent = !1); 25775 break; 25776 25777 case "keypress": 25778 if (!0 === c.skipKeyPressEvent) return t.preventDefault(); 25779 c.skipKeyPressEvent = !0; 25780 break; 25781 25782 case "click": 25783 case "focus": 25784 return c.validationEvent ? (c.validationEvent = !1, e.blur(), (0, o.HandleNativePlaceholder)(e, (c.isRTL ? r.getBufferTemplate.call(c).slice().reverse() : r.getBufferTemplate.call(c)).join("")), 25785 setTimeout((function() { 25786 e.focus(); 25787 }), f.validationEventTimeOut), !1) : (s = arguments, setTimeout((function() { 25788 e.inputmask && i.apply(u, s); 25789 }), 0), !1); 25790 } 25791 var p = i.apply(u, arguments); 25792 return !1 === p && (t.preventDefault(), t.stopPropagation()), p; 25793 } 25794 t.preventDefault(); 25795 } 25796 }; 25797 [ "submit", "reset" ].includes(t) ? (s = s.bind(e), null !== e.form && l(e.form).on(t, s)) : l(e).on(t, s), 25798 e.inputmask.events[t] = e.inputmask.events[t] || [], e.inputmask.events[t].push(s); 25799 }, 25800 off: function(e, t) { 25801 if (e.inputmask && e.inputmask.events) { 25802 var i = e.inputmask.dependencyLib, a = e.inputmask.events; 25803 for (var n in t && ((a = [])[t] = e.inputmask.events[t]), a) { 25804 for (var r = a[n]; r.length > 0; ) { 25805 var o = r.pop(); 25806 [ "submit", "reset" ].includes(n) ? null !== e.form && i(e.form).off(n, o) : i(e).off(n, o); 25807 } 25808 delete e.inputmask.events[n]; 25809 } 25810 } 25811 } 25812 }; 25813 t.EventRuler = s; 25814 }, 25815 219: function(e, t, i) { 25816 var a = d(i(2394)), n = d(i(5581)), r = d(i(7184)), o = i(8711), l = i(4713); 25817 function s(e) { 25818 return s = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) { 25819 return typeof e; 25820 } : function(e) { 25821 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e; 25822 }, s(e); 25823 } 25824 function u(e, t) { 25825 return function(e) { 25826 if (Array.isArray(e)) return e; 25827 }(e) || function(e, t) { 25828 var i = null == e ? null : "undefined" != typeof Symbol && e[Symbol.iterator] || e["@@iterator"]; 25829 if (null == i) return; 25830 var a, n, r = [], o = !0, l = !1; 25831 try { 25832 for (i = i.call(e); !(o = (a = i.next()).done) && (r.push(a.value), !t || r.length !== t); o = !0) ; 25833 } catch (e) { 25834 l = !0, n = e; 25835 } finally { 25836 try { 25837 o || null == i.return || i.return(); 25838 } finally { 25839 if (l) throw n; 25840 } 25841 } 25842 return r; 25843 }(e, t) || function(e, t) { 25844 if (!e) return; 25845 if ("string" == typeof e) return c(e, t); 25846 var i = Object.prototype.toString.call(e).slice(8, -1); 25847 "Object" === i && e.constructor && (i = e.constructor.name); 25848 if ("Map" === i || "Set" === i) return Array.from(e); 25849 if ("Arguments" === i || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(i)) return c(e, t); 25850 }(e, t) || function() { 25851 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 25852 }(); 25853 } 25854 function c(e, t) { 25855 (null == t || t > e.length) && (t = e.length); 25856 for (var i = 0, a = new Array(t); i < t; i++) a[i] = e[i]; 25857 return a; 25858 } 25859 function f(e, t) { 25860 for (var i = 0; i < t.length; i++) { 25861 var a = t[i]; 25862 a.enumerable = a.enumerable || !1, a.configurable = !0, "value" in a && (a.writable = !0), 25863 Object.defineProperty(e, a.key, a); 25864 } 25865 } 25866 function d(e) { 25867 return e && e.__esModule ? e : { 25868 default: e 25869 }; 25870 } 25871 var p = a.default.dependencyLib, h = function() { 25872 function e(t, i, a) { 25873 !function(e, t) { 25874 if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function"); 25875 }(this, e), this.mask = t, this.format = i, this.opts = a, this._date = new Date(1, 0, 1), 25876 this.initDateObject(t, this.opts); 25877 } 25878 var t, i, a; 25879 return t = e, (i = [ { 25880 key: "date", 25881 get: function() { 25882 return void 0 === this._date && (this._date = new Date(1, 0, 1), this.initDateObject(void 0, this.opts)), 25883 this._date; 25884 } 25885 }, { 25886 key: "initDateObject", 25887 value: function(e, t) { 25888 var i; 25889 for (P(t).lastIndex = 0; i = P(t).exec(this.format); ) { 25890 var a = new RegExp("\\d+$").exec(i[0]), n = a ? i[0][0] + "x" : i[0], r = void 0; 25891 if (void 0 !== e) { 25892 if (a) { 25893 var o = P(t).lastIndex, l = O(i.index, t); 25894 P(t).lastIndex = o, r = e.slice(0, e.indexOf(l.nextMatch[0])); 25895 } else r = e.slice(0, n.length); 25896 e = e.slice(r.length); 25897 } 25898 Object.prototype.hasOwnProperty.call(g, n) && this.setValue(this, r, n, g[n][2], g[n][1]); 25899 } 25900 } 25901 }, { 25902 key: "setValue", 25903 value: function(e, t, i, a, n) { 25904 if (void 0 !== t && (e[a] = "ampm" === a ? t : t.replace(/[^0-9]/g, "0"), e["raw" + a] = t.replace(/\s/g, "_")), 25905 void 0 !== n) { 25906 var r = e[a]; 25907 ("day" === a && 29 === parseInt(r) || "month" === a && 2 === parseInt(r)) && (29 !== parseInt(e.day) || 2 !== parseInt(e.month) || "" !== e.year && void 0 !== e.year || e._date.setFullYear(2012, 1, 29)), 25908 "day" === a && (m = !0, 0 === parseInt(r) && (r = 1)), "month" === a && (m = !0), 25909 "year" === a && (m = !0, r.length < 4 && (r = _(r, 4, !0))), "" === r || isNaN(r) || n.call(e._date, r), 25910 "ampm" === a && n.call(e._date, r); 25911 } 25912 } 25913 }, { 25914 key: "reset", 25915 value: function() { 25916 this._date = new Date(1, 0, 1); 25917 } 25918 }, { 25919 key: "reInit", 25920 value: function() { 25921 this._date = void 0, this.date; 25922 } 25923 } ]) && f(t.prototype, i), a && f(t, a), Object.defineProperty(t, "prototype", { 25924 writable: !1 25925 }), e; 25926 }(), v = (new Date).getFullYear(), m = !1, g = { 25927 d: [ "[1-9]|[12][0-9]|3[01]", Date.prototype.setDate, "day", Date.prototype.getDate ], 25928 dd: [ "0[1-9]|[12][0-9]|3[01]", Date.prototype.setDate, "day", function() { 25929 return _(Date.prototype.getDate.call(this), 2); 25930 } ], 25931 ddd: [ "" ], 25932 dddd: [ "" ], 25933 m: [ "[1-9]|1[012]", function(e) { 25934 var t = e ? parseInt(e) : 0; 25935 return t > 0 && t--, Date.prototype.setMonth.call(this, t); 25936 }, "month", function() { 25937 return Date.prototype.getMonth.call(this) + 1; 25938 } ], 25939 mm: [ "0[1-9]|1[012]", function(e) { 25940 var t = e ? parseInt(e) : 0; 25941 return t > 0 && t--, Date.prototype.setMonth.call(this, t); 25942 }, "month", function() { 25943 return _(Date.prototype.getMonth.call(this) + 1, 2); 25944 } ], 25945 mmm: [ "" ], 25946 mmmm: [ "" ], 25947 yy: [ "[0-9]{2}", Date.prototype.setFullYear, "year", function() { 25948 return _(Date.prototype.getFullYear.call(this), 2); 25949 } ], 25950 yyyy: [ "[0-9]{4}", Date.prototype.setFullYear, "year", function() { 25951 return _(Date.prototype.getFullYear.call(this), 4); 25952 } ], 25953 h: [ "[1-9]|1[0-2]", Date.prototype.setHours, "hours", Date.prototype.getHours ], 25954 hh: [ "0[1-9]|1[0-2]", Date.prototype.setHours, "hours", function() { 25955 return _(Date.prototype.getHours.call(this), 2); 25956 } ], 25957 hx: [ function(e) { 25958 return "[0-9]{".concat(e, "}"); 25959 }, Date.prototype.setHours, "hours", function(e) { 25960 return Date.prototype.getHours; 25961 } ], 25962 H: [ "1?[0-9]|2[0-3]", Date.prototype.setHours, "hours", Date.prototype.getHours ], 25963 HH: [ "0[0-9]|1[0-9]|2[0-3]", Date.prototype.setHours, "hours", function() { 25964 return _(Date.prototype.getHours.call(this), 2); 25965 } ], 25966 Hx: [ function(e) { 25967 return "[0-9]{".concat(e, "}"); 25968 }, Date.prototype.setHours, "hours", function(e) { 25969 return function() { 25970 return _(Date.prototype.getHours.call(this), e); 25971 }; 25972 } ], 25973 M: [ "[1-5]?[0-9]", Date.prototype.setMinutes, "minutes", Date.prototype.getMinutes ], 25974 MM: [ "0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]", Date.prototype.setMinutes, "minutes", function() { 25975 return _(Date.prototype.getMinutes.call(this), 2); 25976 } ], 25977 s: [ "[1-5]?[0-9]", Date.prototype.setSeconds, "seconds", Date.prototype.getSeconds ], 25978 ss: [ "0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]", Date.prototype.setSeconds, "seconds", function() { 25979 return _(Date.prototype.getSeconds.call(this), 2); 25980 } ], 25981 l: [ "[0-9]{3}", Date.prototype.setMilliseconds, "milliseconds", function() { 25982 return _(Date.prototype.getMilliseconds.call(this), 3); 25983 } ], 25984 L: [ "[0-9]{2}", Date.prototype.setMilliseconds, "milliseconds", function() { 25985 return _(Date.prototype.getMilliseconds.call(this), 2); 25986 } ], 25987 t: [ "[ap]", y, "ampm", b, 1 ], 25988 tt: [ "[ap]m", y, "ampm", b, 2 ], 25989 T: [ "[AP]", y, "ampm", b, 1 ], 25990 TT: [ "[AP]M", y, "ampm", b, 2 ], 25991 Z: [ ".*", void 0, "Z", function() { 25992 var e = this.toString().match(/\((.+)\)/)[1]; 25993 e.includes(" ") && (e = (e = e.replace("-", " ").toUpperCase()).split(" ").map((function(e) { 25994 return u(e, 1)[0]; 25995 })).join("")); 25996 return e; 25997 } ], 25998 o: [ "" ], 25999 S: [ "" ] 26000 }, k = { 26001 isoDate: "yyyy-mm-dd", 26002 isoTime: "HH:MM:ss", 26003 isoDateTime: "yyyy-mm-dd'T'HH:MM:ss", 26004 isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'" 26005 }; 26006 function y(e) { 26007 var t = this.getHours(); 26008 e.toLowerCase().includes("p") ? this.setHours(t + 12) : e.toLowerCase().includes("a") && t >= 12 && this.setHours(t - 12); 26009 } 26010 function b() { 26011 var e = this.getHours(); 26012 return (e = e || 12) >= 12 ? "PM" : "AM"; 26013 } 26014 function x(e) { 26015 var t = new RegExp("\\d+$").exec(e[0]); 26016 if (t && void 0 !== t[0]) { 26017 var i = g[e[0][0] + "x"].slice(""); 26018 return i[0] = i[0](t[0]), i[3] = i[3](t[0]), i; 26019 } 26020 if (g[e[0]]) return g[e[0]]; 26021 } 26022 function P(e) { 26023 if (!e.tokenizer) { 26024 var t = [], i = []; 26025 for (var a in g) if (/\.*x$/.test(a)) { 26026 var n = a[0] + "\\d+"; 26027 -1 === i.indexOf(n) && i.push(n); 26028 } else -1 === t.indexOf(a[0]) && t.push(a[0]); 26029 e.tokenizer = "(" + (i.length > 0 ? i.join("|") + "|" : "") + t.join("+|") + ")+?|.", 26030 e.tokenizer = new RegExp(e.tokenizer, "g"); 26031 } 26032 return e.tokenizer; 26033 } 26034 function E(e, t, i) { 26035 if (!m) return !0; 26036 if (void 0 === e.rawday || !isFinite(e.rawday) && new Date(e.date.getFullYear(), isFinite(e.rawmonth) ? e.month : e.date.getMonth() + 1, 0).getDate() >= e.day || "29" == e.day && (!isFinite(e.rawyear) || void 0 === e.rawyear || "" === e.rawyear) || new Date(e.date.getFullYear(), isFinite(e.rawmonth) ? e.month : e.date.getMonth() + 1, 0).getDate() >= e.day) return t; 26037 if ("29" == e.day) { 26038 var a = O(t.pos, i); 26039 if ("yyyy" === a.targetMatch[0] && t.pos - a.targetMatchIndex == 2) return t.remove = t.pos + 1, 26040 t; 26041 } else if ("02" == e.month && "30" == e.day && void 0 !== t.c) return e.day = "03", 26042 e.date.setDate(3), e.date.setMonth(1), t.insert = [ { 26043 pos: t.pos, 26044 c: "0" 26045 }, { 26046 pos: t.pos + 1, 26047 c: t.c 26048 } ], t.caret = o.seekNext.call(this, t.pos + 1), t; 26049 return !1; 26050 } 26051 function S(e, t, i, a) { 26052 var n, o, l = ""; 26053 for (P(i).lastIndex = 0; n = P(i).exec(e); ) { 26054 if (void 0 === t) if (o = x(n)) l += "(" + o[0] + ")"; else switch (n[0]) { 26055 case "[": 26056 l += "("; 26057 break; 26058 26059 case "]": 26060 l += ")?"; 26061 break; 26062 26063 default: 26064 l += (0, r.default)(n[0]); 26065 } else if (o = x(n)) if (!0 !== a && o[3]) l += o[3].call(t.date); else o[2] ? l += t["raw" + o[2]] : l += n[0]; else l += n[0]; 26066 } 26067 return l; 26068 } 26069 function _(e, t, i) { 26070 for (e = String(e), t = t || 2; e.length < t; ) e = i ? e + "0" : "0" + e; 26071 return e; 26072 } 26073 function w(e, t, i) { 26074 return "string" == typeof e ? new h(e, t, i) : e && "object" === s(e) && Object.prototype.hasOwnProperty.call(e, "date") ? e : void 0; 26075 } 26076 function M(e, t) { 26077 return S(t.inputFormat, { 26078 date: e 26079 }, t); 26080 } 26081 function O(e, t) { 26082 var i, a, n = 0, r = 0; 26083 for (P(t).lastIndex = 0; a = P(t).exec(t.inputFormat); ) { 26084 var o = new RegExp("\\d+$").exec(a[0]); 26085 if ((n += r = o ? parseInt(o[0]) : a[0].length) >= e + 1) { 26086 i = a, a = P(t).exec(t.inputFormat); 26087 break; 26088 } 26089 } 26090 return { 26091 targetMatchIndex: n - r, 26092 nextMatch: a, 26093 targetMatch: i 26094 }; 26095 } 26096 a.default.extendAliases({ 26097 datetime: { 26098 mask: function(e) { 26099 return e.numericInput = !1, g.S = e.i18n.ordinalSuffix.join("|"), e.inputFormat = k[e.inputFormat] || e.inputFormat, 26100 e.displayFormat = k[e.displayFormat] || e.displayFormat || e.inputFormat, e.outputFormat = k[e.outputFormat] || e.outputFormat || e.inputFormat, 26101 e.placeholder = "" !== e.placeholder ? e.placeholder : e.inputFormat.replace(/[[\]]/, ""), 26102 e.regex = S(e.inputFormat, void 0, e), e.min = w(e.min, e.inputFormat, e), e.max = w(e.max, e.inputFormat, e), 26103 null; 26104 }, 26105 placeholder: "", 26106 inputFormat: "isoDateTime", 26107 displayFormat: null, 26108 outputFormat: null, 26109 min: null, 26110 max: null, 26111 skipOptionalPartCharacter: "", 26112 i18n: { 26113 dayNames: [ "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" ], 26114 monthNames: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ], 26115 ordinalSuffix: [ "st", "nd", "rd", "th" ] 26116 }, 26117 preValidation: function(e, t, i, a, n, r, o, l) { 26118 if (l) return !0; 26119 if (isNaN(i) && e[t] !== i) { 26120 var s = O(t, n); 26121 if (s.nextMatch && s.nextMatch[0] === i && s.targetMatch[0].length > 1) { 26122 var u = g[s.targetMatch[0]][0]; 26123 if (new RegExp(u).test("0" + e[t - 1])) return e[t] = e[t - 1], e[t - 1] = "0", 26124 { 26125 fuzzy: !0, 26126 buffer: e, 26127 refreshFromBuffer: { 26128 start: t - 1, 26129 end: t + 1 26130 }, 26131 pos: t + 1 26132 }; 26133 } 26134 } 26135 return !0; 26136 }, 26137 postValidation: function(e, t, i, a, n, r, o, s) { 26138 var u, c; 26139 if (o) return !0; 26140 if (!1 === a && (((u = O(t + 1, n)).targetMatch && u.targetMatchIndex === t && u.targetMatch[0].length > 1 && void 0 !== g[u.targetMatch[0]] || (u = O(t + 2, n)).targetMatch && u.targetMatchIndex === t + 1 && u.targetMatch[0].length > 1 && void 0 !== g[u.targetMatch[0]]) && (c = g[u.targetMatch[0]][0]), 26141 void 0 !== c && (void 0 !== r.validPositions[t + 1] && new RegExp(c).test(i + "0") ? (e[t] = i, 26142 e[t + 1] = "0", a = { 26143 pos: t + 2, 26144 caret: t 26145 }) : new RegExp(c).test("0" + i) && (e[t] = "0", e[t + 1] = i, a = { 26146 pos: t + 2 26147 })), !1 === a)) return a; 26148 if (a.fuzzy && (e = a.buffer, t = a.pos), (u = O(t, n)).targetMatch && u.targetMatch[0] && void 0 !== g[u.targetMatch[0]]) { 26149 var f = g[u.targetMatch[0]]; 26150 c = f[0]; 26151 var d = e.slice(u.targetMatchIndex, u.targetMatchIndex + u.targetMatch[0].length); 26152 if (!1 === new RegExp(c).test(d.join("")) && 2 === u.targetMatch[0].length && r.validPositions[u.targetMatchIndex] && r.validPositions[u.targetMatchIndex + 1] && (r.validPositions[u.targetMatchIndex + 1].input = "0"), 26153 "year" == f[2]) for (var p = l.getMaskTemplate.call(this, !1, 1, void 0, !0), h = t + 1; h < e.length; h++) e[h] = p[h], 26154 delete r.validPositions[h]; 26155 } 26156 var m = a, k = w(e.join(""), n.inputFormat, n); 26157 return m && k.date.getTime() == k.date.getTime() && (n.prefillYear && (m = function(e, t, i) { 26158 if (e.year !== e.rawyear) { 26159 var a = v.toString(), n = e.rawyear.replace(/[^0-9]/g, ""), r = a.slice(0, n.length), o = a.slice(n.length); 26160 if (2 === n.length && n === r) { 26161 var l = new Date(v, e.month - 1, e.day); 26162 e.day == l.getDate() && (!i.max || i.max.date.getTime() >= l.getTime()) && (e.date.setFullYear(v), 26163 e.year = a, t.insert = [ { 26164 pos: t.pos + 1, 26165 c: o[0] 26166 }, { 26167 pos: t.pos + 2, 26168 c: o[1] 26169 } ]); 26170 } 26171 } 26172 return t; 26173 }(k, m, n)), m = function(e, t, i, a, n) { 26174 if (!t) return t; 26175 if (t && i.min && i.min.date.getTime() == i.min.date.getTime()) { 26176 var r; 26177 for (e.reset(), P(i).lastIndex = 0; r = P(i).exec(i.inputFormat); ) { 26178 var o; 26179 if ((o = x(r)) && o[3]) { 26180 for (var l = o[1], s = e[o[2]], u = i.min[o[2]], c = i.max ? i.max[o[2]] : u, f = [], d = !1, p = 0; p < u.length; p++) void 0 !== a.validPositions[p + r.index] || d ? (f[p] = s[p], 26181 d = d || s[p] > u[p]) : (f[p] = u[p], "year" === o[2] && s.length - 1 == p && u != c && (f = (parseInt(f.join("")) + 1).toString().split("")), 26182 "ampm" === o[2] && u != c && i.min.date.getTime() > e.date.getTime() && (f[p] = c[p])); 26183 l.call(e._date, f.join("")); 26184 } 26185 } 26186 t = i.min.date.getTime() <= e.date.getTime(), e.reInit(); 26187 } 26188 return t && i.max && i.max.date.getTime() == i.max.date.getTime() && (t = i.max.date.getTime() >= e.date.getTime()), 26189 t; 26190 }(k, m = E.call(this, k, m, n), n, r)), void 0 !== t && m && a.pos !== t ? { 26191 buffer: S(n.inputFormat, k, n).split(""), 26192 refreshFromBuffer: { 26193 start: t, 26194 end: a.pos 26195 }, 26196 pos: a.caret || a.pos 26197 } : m; 26198 }, 26199 onKeyDown: function(e, t, i, a) { 26200 e.ctrlKey && e.keyCode === n.default.RIGHT && (this.inputmask._valueSet(M(new Date, a)), 26201 p(this).trigger("setvalue")); 26202 }, 26203 onUnMask: function(e, t, i) { 26204 return t ? S(i.outputFormat, w(e, i.inputFormat, i), i, !0) : t; 26205 }, 26206 casing: function(e, t, i, a) { 26207 return 0 == t.nativeDef.indexOf("[ap]") ? e.toLowerCase() : 0 == t.nativeDef.indexOf("[AP]") ? e.toUpperCase() : e; 26208 }, 26209 onBeforeMask: function(e, t) { 26210 return "[object Date]" === Object.prototype.toString.call(e) && (e = M(e, t)), e; 26211 }, 26212 insertMode: !1, 26213 shiftPositions: !1, 26214 keepStatic: !1, 26215 inputmode: "numeric", 26216 prefillYear: !0 26217 } 26218 }); 26219 }, 26220 3851: function(e, t, i) { 26221 var a, n = (a = i(2394)) && a.__esModule ? a : { 26222 default: a 26223 }, r = i(8711), o = i(4713); 26224 n.default.extendDefinitions({ 26225 A: { 26226 validator: "[A-Za-z\u0410-\u044f\u0401\u0451\xc0-\xff\xb5]", 26227 casing: "upper" 26228 }, 26229 "&": { 26230 validator: "[0-9A-Za-z\u0410-\u044f\u0401\u0451\xc0-\xff\xb5]", 26231 casing: "upper" 26232 }, 26233 "#": { 26234 validator: "[0-9A-Fa-f]", 26235 casing: "upper" 26236 } 26237 }); 26238 var l = new RegExp("25[0-5]|2[0-4][0-9]|[01][0-9][0-9]"); 26239 function s(e, t, i, a, n) { 26240 return i - 1 > -1 && "." !== t.buffer[i - 1] ? (e = t.buffer[i - 1] + e, e = i - 2 > -1 && "." !== t.buffer[i - 2] ? t.buffer[i - 2] + e : "0" + e) : e = "00" + e, 26241 l.test(e); 26242 } 26243 n.default.extendAliases({ 26244 cssunit: { 26245 regex: "[+-]?[0-9]+\\.?([0-9]+)?(px|em|rem|ex|%|in|cm|mm|pt|pc)" 26246 }, 26247 url: { 26248 regex: "(https?|ftp)://.*", 26249 autoUnmask: !1, 26250 keepStatic: !1, 26251 tabThrough: !0 26252 }, 26253 ip: { 26254 mask: "i{1,3}.j{1,3}.k{1,3}.l{1,3}", 26255 definitions: { 26256 i: { 26257 validator: s 26258 }, 26259 j: { 26260 validator: s 26261 }, 26262 k: { 26263 validator: s 26264 }, 26265 l: { 26266 validator: s 26267 } 26268 }, 26269 onUnMask: function(e, t, i) { 26270 return e; 26271 }, 26272 inputmode: "decimal", 26273 substitutes: { 26274 ",": "." 26275 } 26276 }, 26277 email: { 26278 mask: function(e) { 26279 var t = "*{1,64}[.*{1,64}][.*{1,64}][.*{1,63}]@-{1,63}.-{1,63}[.-{1,63}][.-{1,63}]", i = t; 26280 if (e.separator) for (var a = 0; a < e.quantifier; a++) i += "[".concat(e.separator).concat(t, "]"); 26281 return i; 26282 }, 26283 greedy: !1, 26284 casing: "lower", 26285 separator: null, 26286 quantifier: 5, 26287 skipOptionalPartCharacter: "", 26288 onBeforePaste: function(e, t) { 26289 return (e = e.toLowerCase()).replace("mailto:", ""); 26290 }, 26291 definitions: { 26292 "*": { 26293 validator: "[0-9\uff11-\uff19A-Za-z\u0410-\u044f\u0401\u0451\xc0-\xff\xb5!#$%&'*+/=?^_`{|}~-]" 26294 }, 26295 "-": { 26296 validator: "[0-9A-Za-z-]" 26297 } 26298 }, 26299 onUnMask: function(e, t, i) { 26300 return e; 26301 }, 26302 inputmode: "email" 26303 }, 26304 mac: { 26305 mask: "##:##:##:##:##:##" 26306 }, 26307 vin: { 26308 mask: "V{13}9{4}", 26309 definitions: { 26310 V: { 26311 validator: "[A-HJ-NPR-Za-hj-npr-z\\d]", 26312 casing: "upper" 26313 } 26314 }, 26315 clearIncomplete: !0, 26316 autoUnmask: !0 26317 }, 26318 ssn: { 26319 mask: "999-99-9999", 26320 postValidation: function(e, t, i, a, n, l, s) { 26321 var u = o.getMaskTemplate.call(this, !0, r.getLastValidPosition.call(this), !0, !0); 26322 return /^(?!219-09-9999|078-05-1120)(?!666|000|9.{2}).{3}-(?!00).{2}-(?!0{4}).{4}$/.test(u.join("")); 26323 } 26324 } 26325 }); 26326 }, 26327 207: function(e, t, i) { 26328 var a = l(i(2394)), n = l(i(5581)), r = l(i(7184)), o = i(8711); 26329 function l(e) { 26330 return e && e.__esModule ? e : { 26331 default: e 26332 }; 26333 } 26334 var s = a.default.dependencyLib; 26335 function u(e, t) { 26336 for (var i = "", n = 0; n < e.length; n++) a.default.prototype.definitions[e.charAt(n)] || t.definitions[e.charAt(n)] || t.optionalmarker[0] === e.charAt(n) || t.optionalmarker[1] === e.charAt(n) || t.quantifiermarker[0] === e.charAt(n) || t.quantifiermarker[1] === e.charAt(n) || t.groupmarker[0] === e.charAt(n) || t.groupmarker[1] === e.charAt(n) || t.alternatormarker === e.charAt(n) ? i += "\\" + e.charAt(n) : i += e.charAt(n); 26337 return i; 26338 } 26339 function c(e, t, i, a) { 26340 if (e.length > 0 && t > 0 && (!i.digitsOptional || a)) { 26341 var n = e.indexOf(i.radixPoint), r = !1; 26342 i.negationSymbol.back === e[e.length - 1] && (r = !0, e.length--), -1 === n && (e.push(i.radixPoint), 26343 n = e.length - 1); 26344 for (var o = 1; o <= t; o++) isFinite(e[n + o]) || (e[n + o] = "0"); 26345 } 26346 return r && e.push(i.negationSymbol.back), e; 26347 } 26348 function f(e, t) { 26349 var i = 0; 26350 if ("+" === e) { 26351 for (i in t.validPositions) ; 26352 i = o.seekNext.call(this, parseInt(i)); 26353 } 26354 for (var a in t.tests) if ((a = parseInt(a)) >= i) for (var n = 0, r = t.tests[a].length; n < r; n++) if ((void 0 === t.validPositions[a] || "-" === e) && t.tests[a][n].match.def === e) return a + (void 0 !== t.validPositions[a] && "-" !== e ? 1 : 0); 26355 return i; 26356 } 26357 function d(e, t) { 26358 var i = -1; 26359 for (var a in t.validPositions) { 26360 var n = t.validPositions[a]; 26361 if (n && n.match.def === e) { 26362 i = parseInt(a); 26363 break; 26364 } 26365 } 26366 return i; 26367 } 26368 function p(e, t, i, a, n) { 26369 var r = t.buffer ? t.buffer.indexOf(n.radixPoint) : -1, o = (-1 !== r || a && n.jitMasking) && new RegExp(n.definitions[9].validator).test(e); 26370 return n._radixDance && -1 !== r && o && null == t.validPositions[r] ? { 26371 insert: { 26372 pos: r === i ? r + 1 : r, 26373 c: n.radixPoint 26374 }, 26375 pos: i 26376 } : o; 26377 } 26378 a.default.extendAliases({ 26379 numeric: { 26380 mask: function(e) { 26381 e.repeat = 0, e.groupSeparator === e.radixPoint && e.digits && "0" !== e.digits && ("." === e.radixPoint ? e.groupSeparator = "," : "," === e.radixPoint ? e.groupSeparator = "." : e.groupSeparator = ""), 26382 " " === e.groupSeparator && (e.skipOptionalPartCharacter = void 0), e.placeholder.length > 1 && (e.placeholder = e.placeholder.charAt(0)), 26383 "radixFocus" === e.positionCaretOnClick && "" === e.placeholder && (e.positionCaretOnClick = "lvp"); 26384 var t = "0", i = e.radixPoint; 26385 !0 === e.numericInput && void 0 === e.__financeInput ? (t = "1", e.positionCaretOnClick = "radixFocus" === e.positionCaretOnClick ? "lvp" : e.positionCaretOnClick, 26386 e.digitsOptional = !1, isNaN(e.digits) && (e.digits = 2), e._radixDance = !1, i = "," === e.radixPoint ? "?" : "!", 26387 "" !== e.radixPoint && void 0 === e.definitions[i] && (e.definitions[i] = {}, e.definitions[i].validator = "[" + e.radixPoint + "]", 26388 e.definitions[i].placeholder = e.radixPoint, e.definitions[i].static = !0, e.definitions[i].generated = !0)) : (e.__financeInput = !1, 26389 e.numericInput = !0); 26390 var a, n = "[+]"; 26391 if (n += u(e.prefix, e), "" !== e.groupSeparator ? (void 0 === e.definitions[e.groupSeparator] && (e.definitions[e.groupSeparator] = {}, 26392 e.definitions[e.groupSeparator].validator = "[" + e.groupSeparator + "]", e.definitions[e.groupSeparator].placeholder = e.groupSeparator, 26393 e.definitions[e.groupSeparator].static = !0, e.definitions[e.groupSeparator].generated = !0), 26394 n += e._mask(e)) : n += "9{+}", void 0 !== e.digits && 0 !== e.digits) { 26395 var o = e.digits.toString().split(","); 26396 isFinite(o[0]) && o[1] && isFinite(o[1]) ? n += i + t + "{" + e.digits + "}" : (isNaN(e.digits) || parseInt(e.digits) > 0) && (e.digitsOptional || e.jitMasking ? (a = n + i + t + "{0," + e.digits + "}", 26397 e.keepStatic = !0) : n += i + t + "{" + e.digits + "}"); 26398 } else e.inputmode = "numeric"; 26399 return n += u(e.suffix, e), n += "[-]", a && (n = [ a + u(e.suffix, e) + "[-]", n ]), 26400 e.greedy = !1, function(e) { 26401 void 0 === e.parseMinMaxOptions && (null !== e.min && (e.min = e.min.toString().replace(new RegExp((0, 26402 r.default)(e.groupSeparator), "g"), ""), "," === e.radixPoint && (e.min = e.min.replace(e.radixPoint, ".")), 26403 e.min = isFinite(e.min) ? parseFloat(e.min) : NaN, isNaN(e.min) && (e.min = Number.MIN_VALUE)), 26404 null !== e.max && (e.max = e.max.toString().replace(new RegExp((0, r.default)(e.groupSeparator), "g"), ""), 26405 "," === e.radixPoint && (e.max = e.max.replace(e.radixPoint, ".")), e.max = isFinite(e.max) ? parseFloat(e.max) : NaN, 26406 isNaN(e.max) && (e.max = Number.MAX_VALUE)), e.parseMinMaxOptions = "done"); 26407 }(e), "" !== e.radixPoint && (e.substitutes["." == e.radixPoint ? "," : "."] = e.radixPoint), 26408 n; 26409 }, 26410 _mask: function(e) { 26411 return "(" + e.groupSeparator + "999){+|1}"; 26412 }, 26413 digits: "*", 26414 digitsOptional: !0, 26415 enforceDigitsOnBlur: !1, 26416 radixPoint: ".", 26417 positionCaretOnClick: "radixFocus", 26418 _radixDance: !0, 26419 groupSeparator: "", 26420 allowMinus: !0, 26421 negationSymbol: { 26422 front: "-", 26423 back: "" 26424 }, 26425 prefix: "", 26426 suffix: "", 26427 min: null, 26428 max: null, 26429 SetMaxOnOverflow: !1, 26430 step: 1, 26431 inputType: "text", 26432 unmaskAsNumber: !1, 26433 roundingFN: Math.round, 26434 inputmode: "decimal", 26435 shortcuts: { 26436 k: "1000", 26437 m: "1000000" 26438 }, 26439 placeholder: "0", 26440 greedy: !1, 26441 rightAlign: !0, 26442 insertMode: !0, 26443 autoUnmask: !1, 26444 skipOptionalPartCharacter: "", 26445 usePrototypeDefinitions: !1, 26446 stripLeadingZeroes: !0, 26447 definitions: { 26448 0: { 26449 validator: p 26450 }, 26451 1: { 26452 validator: p, 26453 definitionSymbol: "9" 26454 }, 26455 9: { 26456 validator: "[0-9\uff10-\uff19\u0660-\u0669\u06f0-\u06f9]", 26457 definitionSymbol: "*" 26458 }, 26459 "+": { 26460 validator: function(e, t, i, a, n) { 26461 return n.allowMinus && ("-" === e || e === n.negationSymbol.front); 26462 } 26463 }, 26464 "-": { 26465 validator: function(e, t, i, a, n) { 26466 return n.allowMinus && e === n.negationSymbol.back; 26467 } 26468 } 26469 }, 26470 preValidation: function(e, t, i, a, n, r, o, l) { 26471 if (!1 !== n.__financeInput && i === n.radixPoint) return !1; 26472 var s = e.indexOf(n.radixPoint), u = t; 26473 if (t = function(e, t, i, a, n) { 26474 return n._radixDance && n.numericInput && t !== n.negationSymbol.back && e <= i && (i > 0 || t == n.radixPoint) && (void 0 === a.validPositions[e - 1] || a.validPositions[e - 1].input !== n.negationSymbol.back) && (e -= 1), 26475 e; 26476 }(t, i, s, r, n), "-" === i || i === n.negationSymbol.front) { 26477 if (!0 !== n.allowMinus) return !1; 26478 var c = !1, p = d("+", r), h = d("-", r); 26479 return -1 !== p && (c = [ p, h ]), !1 !== c ? { 26480 remove: c, 26481 caret: u - n.negationSymbol.back.length 26482 } : { 26483 insert: [ { 26484 pos: f.call(this, "+", r), 26485 c: n.negationSymbol.front, 26486 fromIsValid: !0 26487 }, { 26488 pos: f.call(this, "-", r), 26489 c: n.negationSymbol.back, 26490 fromIsValid: void 0 26491 } ], 26492 caret: u + n.negationSymbol.back.length 26493 }; 26494 } 26495 if (i === n.groupSeparator) return { 26496 caret: u 26497 }; 26498 if (l) return !0; 26499 if (-1 !== s && !0 === n._radixDance && !1 === a && i === n.radixPoint && void 0 !== n.digits && (isNaN(n.digits) || parseInt(n.digits) > 0) && s !== t) return { 26500 caret: n._radixDance && t === s - 1 ? s + 1 : s 26501 }; 26502 if (!1 === n.__financeInput) if (a) { 26503 if (n.digitsOptional) return { 26504 rewritePosition: o.end 26505 }; 26506 if (!n.digitsOptional) { 26507 if (o.begin > s && o.end <= s) return i === n.radixPoint ? { 26508 insert: { 26509 pos: s + 1, 26510 c: "0", 26511 fromIsValid: !0 26512 }, 26513 rewritePosition: s 26514 } : { 26515 rewritePosition: s + 1 26516 }; 26517 if (o.begin < s) return { 26518 rewritePosition: o.begin - 1 26519 }; 26520 } 26521 } else if (!n.showMaskOnHover && !n.showMaskOnFocus && !n.digitsOptional && n.digits > 0 && "" === this.__valueGet.call(this.el)) return { 26522 rewritePosition: s 26523 }; 26524 return { 26525 rewritePosition: t 26526 }; 26527 }, 26528 postValidation: function(e, t, i, a, n, r, o) { 26529 if (!1 === a) return a; 26530 if (o) return !0; 26531 if (null !== n.min || null !== n.max) { 26532 var l = n.onUnMask(e.slice().reverse().join(""), void 0, s.extend({}, n, { 26533 unmaskAsNumber: !0 26534 })); 26535 if (null !== n.min && l < n.min && (l.toString().length > n.min.toString().length || l < 0)) return !1; 26536 if (null !== n.max && l > n.max) return !!n.SetMaxOnOverflow && { 26537 refreshFromBuffer: !0, 26538 buffer: c(n.max.toString().replace(".", n.radixPoint).split(""), n.digits, n).reverse() 26539 }; 26540 } 26541 return a; 26542 }, 26543 onUnMask: function(e, t, i) { 26544 if ("" === t && !0 === i.nullable) return t; 26545 var a = e.replace(i.prefix, ""); 26546 return a = (a = a.replace(i.suffix, "")).replace(new RegExp((0, r.default)(i.groupSeparator), "g"), ""), 26547 "" !== i.placeholder.charAt(0) && (a = a.replace(new RegExp(i.placeholder.charAt(0), "g"), "0")), 26548 i.unmaskAsNumber ? ("" !== i.radixPoint && -1 !== a.indexOf(i.radixPoint) && (a = a.replace(r.default.call(this, i.radixPoint), ".")), 26549 a = (a = a.replace(new RegExp("^" + (0, r.default)(i.negationSymbol.front)), "-")).replace(new RegExp((0, 26550 r.default)(i.negationSymbol.back) + "$"), ""), Number(a)) : a; 26551 }, 26552 isComplete: function(e, t) { 26553 var i = (t.numericInput ? e.slice().reverse() : e).join(""); 26554 return i = (i = (i = (i = (i = i.replace(new RegExp("^" + (0, r.default)(t.negationSymbol.front)), "-")).replace(new RegExp((0, 26555 r.default)(t.negationSymbol.back) + "$"), "")).replace(t.prefix, "")).replace(t.suffix, "")).replace(new RegExp((0, 26556 r.default)(t.groupSeparator) + "([0-9]{3})", "g"), "$1"), "," === t.radixPoint && (i = i.replace((0, 26557 r.default)(t.radixPoint), ".")), isFinite(i); 26558 }, 26559 onBeforeMask: function(e, t) { 26560 var i = t.radixPoint || ","; 26561 isFinite(t.digits) && (t.digits = parseInt(t.digits)), "number" != typeof e && "number" !== t.inputType || "" === i || (e = e.toString().replace(".", i)); 26562 var a = "-" === e.charAt(0) || e.charAt(0) === t.negationSymbol.front, n = e.split(i), o = n[0].replace(/[^\-0-9]/g, ""), l = n.length > 1 ? n[1].replace(/[^0-9]/g, "") : "", s = n.length > 1; 26563 e = o + ("" !== l ? i + l : l); 26564 var u = 0; 26565 if ("" !== i && (u = t.digitsOptional ? t.digits < l.length ? t.digits : l.length : t.digits, 26566 "" !== l || !t.digitsOptional)) { 26567 var f = Math.pow(10, u || 1); 26568 e = e.replace((0, r.default)(i), "."), isNaN(parseFloat(e)) || (e = (t.roundingFN(parseFloat(e) * f) / f).toFixed(u)), 26569 e = e.toString().replace(".", i); 26570 } 26571 if (0 === t.digits && -1 !== e.indexOf(i) && (e = e.substring(0, e.indexOf(i))), 26572 null !== t.min || null !== t.max) { 26573 var d = e.toString().replace(i, "."); 26574 null !== t.min && d < t.min ? e = t.min.toString().replace(".", i) : null !== t.max && d > t.max && (e = t.max.toString().replace(".", i)); 26575 } 26576 return a && "-" !== e.charAt(0) && (e = "-" + e), c(e.toString().split(""), u, t, s).join(""); 26577 }, 26578 onBeforeWrite: function(e, t, i, a) { 26579 function n(e, t) { 26580 if (!1 !== a.__financeInput || t) { 26581 var i = e.indexOf(a.radixPoint); 26582 -1 !== i && e.splice(i, 1); 26583 } 26584 if ("" !== a.groupSeparator) for (;-1 !== (i = e.indexOf(a.groupSeparator)); ) e.splice(i, 1); 26585 return e; 26586 } 26587 var o, l; 26588 if (a.stripLeadingZeroes && (l = function(e, t) { 26589 var i = new RegExp("(^" + ("" !== t.negationSymbol.front ? (0, r.default)(t.negationSymbol.front) + "?" : "") + (0, 26590 r.default)(t.prefix) + ")(.*)(" + (0, r.default)(t.suffix) + ("" != t.negationSymbol.back ? (0, 26591 r.default)(t.negationSymbol.back) + "?" : "") + "$)").exec(e.slice().reverse().join("")), a = i ? i[2] : "", n = !1; 26592 return a && (a = a.split(t.radixPoint.charAt(0))[0], n = new RegExp("^[0" + t.groupSeparator + "]*").exec(a)), 26593 !(!n || !(n[0].length > 1 || n[0].length > 0 && n[0].length < a.length)) && n; 26594 }(t, a))) for (var u = t.join("").lastIndexOf(l[0].split("").reverse().join("")) - (l[0] == l.input ? 0 : 1), f = l[0] == l.input ? 1 : 0, d = l[0].length - f; d > 0; d--) delete this.maskset.validPositions[u + d], 26595 delete t[u + d]; 26596 if (e) switch (e.type) { 26597 case "blur": 26598 case "checkval": 26599 if (null !== a.min) { 26600 var p = a.onUnMask(t.slice().reverse().join(""), void 0, s.extend({}, a, { 26601 unmaskAsNumber: !0 26602 })); 26603 if (null !== a.min && p < a.min) return { 26604 refreshFromBuffer: !0, 26605 buffer: c(a.min.toString().replace(".", a.radixPoint).split(""), a.digits, a).reverse() 26606 }; 26607 } 26608 if (t[t.length - 1] === a.negationSymbol.front) { 26609 var h = new RegExp("(^" + ("" != a.negationSymbol.front ? (0, r.default)(a.negationSymbol.front) + "?" : "") + (0, 26610 r.default)(a.prefix) + ")(.*)(" + (0, r.default)(a.suffix) + ("" != a.negationSymbol.back ? (0, 26611 r.default)(a.negationSymbol.back) + "?" : "") + "$)").exec(n(t.slice(), !0).reverse().join("")); 26612 0 == (h ? h[2] : "") && (o = { 26613 refreshFromBuffer: !0, 26614 buffer: [ 0 ] 26615 }); 26616 } else if ("" !== a.radixPoint) { 26617 t.indexOf(a.radixPoint) === a.suffix.length && (o && o.buffer ? o.buffer.splice(0, 1 + a.suffix.length) : (t.splice(0, 1 + a.suffix.length), 26618 o = { 26619 refreshFromBuffer: !0, 26620 buffer: n(t) 26621 })); 26622 } 26623 if (a.enforceDigitsOnBlur) { 26624 var v = (o = o || {}) && o.buffer || t.slice().reverse(); 26625 o.refreshFromBuffer = !0, o.buffer = c(v, a.digits, a, !0).reverse(); 26626 } 26627 } 26628 return o; 26629 }, 26630 onKeyDown: function(e, t, i, a) { 26631 var r, o, l = s(this), u = String.fromCharCode(e.keyCode).toLowerCase(); 26632 if ((o = a.shortcuts && a.shortcuts[u]) && o.length > 1) return this.inputmask.__valueSet.call(this, parseFloat(this.inputmask.unmaskedvalue()) * parseInt(o)), 26633 l.trigger("setvalue"), !1; 26634 if (e.ctrlKey) switch (e.keyCode) { 26635 case n.default.UP: 26636 return this.inputmask.__valueSet.call(this, parseFloat(this.inputmask.unmaskedvalue()) + parseInt(a.step)), 26637 l.trigger("setvalue"), !1; 26638 26639 case n.default.DOWN: 26640 return this.inputmask.__valueSet.call(this, parseFloat(this.inputmask.unmaskedvalue()) - parseInt(a.step)), 26641 l.trigger("setvalue"), !1; 26642 } 26643 if (!e.shiftKey && (e.keyCode === n.default.DELETE || e.keyCode === n.default.BACKSPACE || e.keyCode === n.default.BACKSPACE_SAFARI) && i.begin !== t.length) { 26644 if (t[e.keyCode === n.default.DELETE ? i.begin - 1 : i.end] === a.negationSymbol.front) return r = t.slice().reverse(), 26645 "" !== a.negationSymbol.front && r.shift(), "" !== a.negationSymbol.back && r.pop(), 26646 l.trigger("setvalue", [ r.join(""), i.begin ]), !1; 26647 if (!0 === a._radixDance) { 26648 var f = t.indexOf(a.radixPoint); 26649 if (a.digitsOptional) { 26650 if (0 === f) return (r = t.slice().reverse()).pop(), l.trigger("setvalue", [ r.join(""), i.begin >= r.length ? r.length : i.begin ]), 26651 !1; 26652 } else if (-1 !== f && (i.begin < f || i.end < f || e.keyCode === n.default.DELETE && i.begin === f)) return i.begin !== i.end || e.keyCode !== n.default.BACKSPACE && e.keyCode !== n.default.BACKSPACE_SAFARI || i.begin++, 26653 (r = t.slice().reverse()).splice(r.length - i.begin, i.begin - i.end + 1), r = c(r, a.digits, a).join(""), 26654 l.trigger("setvalue", [ r, i.begin >= r.length ? f + 1 : i.begin ]), !1; 26655 } 26656 } 26657 } 26658 }, 26659 currency: { 26660 prefix: "", 26661 groupSeparator: ",", 26662 alias: "numeric", 26663 digits: 2, 26664 digitsOptional: !1 26665 }, 26666 decimal: { 26667 alias: "numeric" 26668 }, 26669 integer: { 26670 alias: "numeric", 26671 inputmode: "numeric", 26672 digits: 0 26673 }, 26674 percentage: { 26675 alias: "numeric", 26676 min: 0, 26677 max: 100, 26678 suffix: " %", 26679 digits: 0, 26680 allowMinus: !1 26681 }, 26682 indianns: { 26683 alias: "numeric", 26684 _mask: function(e) { 26685 return "(" + e.groupSeparator + "99){*|1}(" + e.groupSeparator + "999){1|1}"; 26686 }, 26687 groupSeparator: ",", 26688 radixPoint: ".", 26689 placeholder: "0", 26690 digits: 2, 26691 digitsOptional: !1 26692 } 26693 }); 26694 }, 26695 9380: function(e, t, i) { 26696 var a; 26697 Object.defineProperty(t, "__esModule", { 26698 value: !0 26699 }), t.default = void 0; 26700 var n = ((a = i(8741)) && a.__esModule ? a : { 26701 default: a 26702 }).default ? window : {}; 26703 t.default = n; 26704 }, 26705 7760: function(e, t, i) { 26706 Object.defineProperty(t, "__esModule", { 26707 value: !0 26708 }), t.HandleNativePlaceholder = function(e, t) { 26709 var i = e ? e.inputmask : this; 26710 if (s.ie) { 26711 if (e.inputmask._valueGet() !== t && (e.placeholder !== t || "" === e.placeholder)) { 26712 var a = o.getBuffer.call(i).slice(), n = e.inputmask._valueGet(); 26713 if (n !== t) { 26714 var r = o.getLastValidPosition.call(i); 26715 -1 === r && n === o.getBufferTemplate.call(i).join("") ? a = [] : -1 !== r && f.call(i, a), 26716 p(e, a); 26717 } 26718 } 26719 } else e.placeholder !== t && (e.placeholder = t, "" === e.placeholder && e.removeAttribute("placeholder")); 26720 }, t.applyInputValue = c, t.checkVal = d, t.clearOptionalTail = f, t.unmaskedvalue = function(e) { 26721 var t = e ? e.inputmask : this, i = t.opts, a = t.maskset; 26722 if (e) { 26723 if (void 0 === e.inputmask) return e.value; 26724 e.inputmask && e.inputmask.refreshValue && c(e, e.inputmask._valueGet(!0)); 26725 } 26726 var n = [], r = a.validPositions; 26727 for (var l in r) r[l] && r[l].match && (1 != r[l].match.static || Array.isArray(a.metadata) && !0 !== r[l].generatedInput) && n.push(r[l].input); 26728 var s = 0 === n.length ? "" : (t.isRTL ? n.reverse() : n).join(""); 26729 if ("function" == typeof i.onUnMask) { 26730 var u = (t.isRTL ? o.getBuffer.call(t).slice().reverse() : o.getBuffer.call(t)).join(""); 26731 s = i.onUnMask.call(t, u, s, i); 26732 } 26733 return s; 26734 }, t.writeBuffer = p; 26735 var a, n = (a = i(5581)) && a.__esModule ? a : { 26736 default: a 26737 }, r = i(4713), o = i(8711), l = i(7215), s = i(9845), u = i(6030); 26738 function c(e, t) { 26739 var i = e ? e.inputmask : this, a = i.opts; 26740 e.inputmask.refreshValue = !1, "function" == typeof a.onBeforeMask && (t = a.onBeforeMask.call(i, t, a) || t), 26741 d(e, !0, !1, t = t.toString().split("")), i.undoValue = i._valueGet(!0), (a.clearMaskOnLostFocus || a.clearIncomplete) && e.inputmask._valueGet() === o.getBufferTemplate.call(i).join("") && -1 === o.getLastValidPosition.call(i) && e.inputmask._valueSet(""); 26742 } 26743 function f(e) { 26744 e.length = 0; 26745 for (var t, i = r.getMaskTemplate.call(this, !0, 0, !0, void 0, !0); void 0 !== (t = i.shift()); ) e.push(t); 26746 return e; 26747 } 26748 function d(e, t, i, a, n) { 26749 var s = e ? e.inputmask : this, c = s.maskset, f = s.opts, d = s.dependencyLib, h = a.slice(), v = "", m = -1, g = void 0, k = f.skipOptionalPartCharacter; 26750 f.skipOptionalPartCharacter = "", o.resetMaskSet.call(s), c.tests = {}, m = f.radixPoint ? o.determineNewCaretPosition.call(s, { 26751 begin: 0, 26752 end: 0 26753 }, !1, !1 === f.__financeInput ? "radixFocus" : void 0).begin : 0, c.p = m, s.caretPos = { 26754 begin: m 26755 }; 26756 var y = [], b = s.caretPos; 26757 if (h.forEach((function(e, t) { 26758 if (void 0 !== e) { 26759 var a = new d.Event("_checkval"); 26760 a.keyCode = e.toString().charCodeAt(0), v += e; 26761 var n = o.getLastValidPosition.call(s, void 0, !0); 26762 !function(e, t) { 26763 for (var i = r.getMaskTemplate.call(s, !0, 0).slice(e, o.seekNext.call(s, e, !1, !1)).join("").replace(/'/g, ""), a = i.indexOf(t); a > 0 && " " === i[a - 1]; ) a--; 26764 var n = 0 === a && !o.isMask.call(s, e) && (r.getTest.call(s, e).match.nativeDef === t.charAt(0) || !0 === r.getTest.call(s, e).match.static && r.getTest.call(s, e).match.nativeDef === "'" + t.charAt(0) || " " === r.getTest.call(s, e).match.nativeDef && (r.getTest.call(s, e + 1).match.nativeDef === t.charAt(0) || !0 === r.getTest.call(s, e + 1).match.static && r.getTest.call(s, e + 1).match.nativeDef === "'" + t.charAt(0))); 26765 if (!n && a > 0 && !o.isMask.call(s, e, !1, !0)) { 26766 var l = o.seekNext.call(s, e); 26767 s.caretPos.begin < l && (s.caretPos = { 26768 begin: l 26769 }); 26770 } 26771 return n; 26772 }(m, v) ? (g = u.EventHandlers.keypressEvent.call(s, a, !0, !1, i, s.caretPos.begin)) && (m = s.caretPos.begin + 1, 26773 v = "") : g = u.EventHandlers.keypressEvent.call(s, a, !0, !1, i, n + 1), g ? (void 0 !== g.pos && c.validPositions[g.pos] && !0 === c.validPositions[g.pos].match.static && void 0 === c.validPositions[g.pos].alternation && (y.push(g.pos), 26774 s.isRTL || (g.forwardPosition = g.pos + 1)), p.call(s, void 0, o.getBuffer.call(s), g.forwardPosition, a, !1), 26775 s.caretPos = { 26776 begin: g.forwardPosition, 26777 end: g.forwardPosition 26778 }, b = s.caretPos) : void 0 === c.validPositions[t] && h[t] === r.getPlaceholder.call(s, t) && o.isMask.call(s, t, !0) ? s.caretPos.begin++ : s.caretPos = b; 26779 } 26780 })), y.length > 0) { 26781 var x, P, E = o.seekNext.call(s, -1, void 0, !1); 26782 if (!l.isComplete.call(s, o.getBuffer.call(s)) && y.length <= E || l.isComplete.call(s, o.getBuffer.call(s)) && y.length > 0 && y.length !== E && 0 === y[0]) for (var S = E; void 0 !== (x = y.shift()); ) { 26783 var _ = new d.Event("_checkval"); 26784 if ((P = c.validPositions[x]).generatedInput = !0, _.keyCode = P.input.charCodeAt(0), 26785 (g = u.EventHandlers.keypressEvent.call(s, _, !0, !1, i, S)) && void 0 !== g.pos && g.pos !== x && c.validPositions[g.pos] && !0 === c.validPositions[g.pos].match.static) y.push(g.pos); else if (!g) break; 26786 S++; 26787 } 26788 } 26789 t && p.call(s, e, o.getBuffer.call(s), g ? g.forwardPosition : s.caretPos.begin, n || new d.Event("checkval"), n && ("input" === n.type && s.undoValue !== o.getBuffer.call(s).join("") || "paste" === n.type)), 26790 f.skipOptionalPartCharacter = k; 26791 } 26792 function p(e, t, i, a, r) { 26793 var s = e ? e.inputmask : this, u = s.opts, c = s.dependencyLib; 26794 if (a && "function" == typeof u.onBeforeWrite) { 26795 var f = u.onBeforeWrite.call(s, a, t, i, u); 26796 if (f) { 26797 if (f.refreshFromBuffer) { 26798 var d = f.refreshFromBuffer; 26799 l.refreshFromBuffer.call(s, !0 === d ? d : d.start, d.end, f.buffer || t), t = o.getBuffer.call(s, !0); 26800 } 26801 void 0 !== i && (i = void 0 !== f.caret ? f.caret : i); 26802 } 26803 } 26804 if (void 0 !== e && (e.inputmask._valueSet(t.join("")), void 0 === i || void 0 !== a && "blur" === a.type || o.caret.call(s, e, i, void 0, void 0, void 0 !== a && "keydown" === a.type && (a.keyCode === n.default.DELETE || a.keyCode === n.default.BACKSPACE)), 26805 !0 === r)) { 26806 var p = c(e), h = e.inputmask._valueGet(); 26807 e.inputmask.skipInputEvent = !0, p.trigger("input"), setTimeout((function() { 26808 h === o.getBufferTemplate.call(s).join("") ? p.trigger("cleared") : !0 === l.isComplete.call(s, t) && p.trigger("complete"); 26809 }), 0); 26810 } 26811 } 26812 }, 26813 2394: function(e, t, i) { 26814 Object.defineProperty(t, "__esModule", { 26815 value: !0 26816 }), t.default = void 0, i(7149), i(3194); 26817 var a = i(157), n = m(i(4963)), r = m(i(9380)), o = i(2391), l = i(4713), s = i(8711), u = i(7215), c = i(7760), f = i(9716), d = m(i(7392)), p = m(i(3976)), h = m(i(8741)); 26818 function v(e) { 26819 return v = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) { 26820 return typeof e; 26821 } : function(e) { 26822 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e; 26823 }, v(e); 26824 } 26825 function m(e) { 26826 return e && e.__esModule ? e : { 26827 default: e 26828 }; 26829 } 26830 var g = r.default.document, k = "_inputmask_opts"; 26831 function y(e, t, i) { 26832 if (h.default) { 26833 if (!(this instanceof y)) return new y(e, t, i); 26834 this.dependencyLib = n.default, this.el = void 0, this.events = {}, this.maskset = void 0, 26835 !0 !== i && ("[object Object]" === Object.prototype.toString.call(e) ? t = e : (t = t || {}, 26836 e && (t.alias = e)), this.opts = n.default.extend(!0, {}, this.defaults, t), this.noMasksCache = t && void 0 !== t.definitions, 26837 this.userOptions = t || {}, b(this.opts.alias, t, this.opts)), this.refreshValue = !1, 26838 this.undoValue = void 0, this.$el = void 0, this.skipKeyPressEvent = !1, this.skipInputEvent = !1, 26839 this.validationEvent = !1, this.ignorable = !1, this.maxLength, this.mouseEnter = !1, 26840 this.originalPlaceholder = void 0, this.isComposing = !1; 26841 } 26842 } 26843 function b(e, t, i) { 26844 var a = y.prototype.aliases[e]; 26845 return a ? (a.alias && b(a.alias, void 0, i), n.default.extend(!0, i, a), n.default.extend(!0, i, t), 26846 !0) : (null === i.mask && (i.mask = e), !1); 26847 } 26848 y.prototype = { 26849 dataAttribute: "data-inputmask", 26850 defaults: p.default, 26851 definitions: d.default, 26852 aliases: {}, 26853 masksCache: {}, 26854 get isRTL() { 26855 return this.opts.isRTL || this.opts.numericInput; 26856 }, 26857 mask: function(e) { 26858 var t = this; 26859 return "string" == typeof e && (e = g.getElementById(e) || g.querySelectorAll(e)), 26860 (e = e.nodeName ? [ e ] : Array.isArray(e) ? e : Array.from(e)).forEach((function(e, i) { 26861 var l = n.default.extend(!0, {}, t.opts); 26862 if (function(e, t, i, a) { 26863 function o(t, n) { 26864 var o = "" === a ? t : a + "-" + t; 26865 null !== (n = void 0 !== n ? n : e.getAttribute(o)) && ("string" == typeof n && (0 === t.indexOf("on") ? n = r.default[n] : "false" === n ? n = !1 : "true" === n && (n = !0)), 26866 i[t] = n); 26867 } 26868 if (!0 === t.importDataAttributes) { 26869 var l, s, u, c, f = e.getAttribute(a); 26870 if (f && "" !== f && (f = f.replace(/'/g, '"'), s = JSON.parse("{" + f + "}")), 26871 s) for (c in u = void 0, s) if ("alias" === c.toLowerCase()) { 26872 u = s[c]; 26873 break; 26874 } 26875 for (l in o("alias", u), i.alias && b(i.alias, i, t), t) { 26876 if (s) for (c in u = void 0, s) if (c.toLowerCase() === l.toLowerCase()) { 26877 u = s[c]; 26878 break; 26879 } 26880 o(l, u); 26881 } 26882 } 26883 n.default.extend(!0, t, i), ("rtl" === e.dir || t.rightAlign) && (e.style.textAlign = "right"); 26884 ("rtl" === e.dir || t.numericInput) && (e.dir = "ltr", e.removeAttribute("dir"), 26885 t.isRTL = !0); 26886 return Object.keys(i).length; 26887 }(e, l, n.default.extend(!0, {}, t.userOptions), t.dataAttribute)) { 26888 var s = (0, o.generateMaskSet)(l, t.noMasksCache); 26889 void 0 !== s && (void 0 !== e.inputmask && (e.inputmask.opts.autoUnmask = !0, e.inputmask.remove()), 26890 e.inputmask = new y(void 0, void 0, !0), e.inputmask.opts = l, e.inputmask.noMasksCache = t.noMasksCache, 26891 e.inputmask.userOptions = n.default.extend(!0, {}, t.userOptions), e.inputmask.el = e, 26892 e.inputmask.$el = (0, n.default)(e), e.inputmask.maskset = s, n.default.data(e, k, t.userOptions), 26893 a.mask.call(e.inputmask)); 26894 } 26895 })), e && e[0] && e[0].inputmask || this; 26896 }, 26897 option: function(e, t) { 26898 return "string" == typeof e ? this.opts[e] : "object" === v(e) ? (n.default.extend(this.userOptions, e), 26899 this.el && !0 !== t && this.mask(this.el), this) : void 0; 26900 }, 26901 unmaskedvalue: function(e) { 26902 if (this.maskset = this.maskset || (0, o.generateMaskSet)(this.opts, this.noMasksCache), 26903 void 0 === this.el || void 0 !== e) { 26904 var t = ("function" == typeof this.opts.onBeforeMask && this.opts.onBeforeMask.call(this, e, this.opts) || e).split(""); 26905 c.checkVal.call(this, void 0, !1, !1, t), "function" == typeof this.opts.onBeforeWrite && this.opts.onBeforeWrite.call(this, void 0, s.getBuffer.call(this), 0, this.opts); 26906 } 26907 return c.unmaskedvalue.call(this, this.el); 26908 }, 26909 remove: function() { 26910 if (this.el) { 26911 n.default.data(this.el, k, null); 26912 var e = this.opts.autoUnmask ? (0, c.unmaskedvalue)(this.el) : this._valueGet(this.opts.autoUnmask); 26913 e !== s.getBufferTemplate.call(this).join("") ? this._valueSet(e, this.opts.autoUnmask) : this._valueSet(""), 26914 f.EventRuler.off(this.el), Object.getOwnPropertyDescriptor && Object.getPrototypeOf ? Object.getOwnPropertyDescriptor(Object.getPrototypeOf(this.el), "value") && this.__valueGet && Object.defineProperty(this.el, "value", { 26915 get: this.__valueGet, 26916 set: this.__valueSet, 26917 configurable: !0 26918 }) : g.__lookupGetter__ && this.el.__lookupGetter__("value") && this.__valueGet && (this.el.__defineGetter__("value", this.__valueGet), 26919 this.el.__defineSetter__("value", this.__valueSet)), this.el.inputmask = void 0; 26920 } 26921 return this.el; 26922 }, 26923 getemptymask: function() { 26924 return this.maskset = this.maskset || (0, o.generateMaskSet)(this.opts, this.noMasksCache), 26925 s.getBufferTemplate.call(this).join(""); 26926 }, 26927 hasMaskedValue: function() { 26928 return !this.opts.autoUnmask; 26929 }, 26930 isComplete: function() { 26931 return this.maskset = this.maskset || (0, o.generateMaskSet)(this.opts, this.noMasksCache), 26932 u.isComplete.call(this, s.getBuffer.call(this)); 26933 }, 26934 getmetadata: function() { 26935 if (this.maskset = this.maskset || (0, o.generateMaskSet)(this.opts, this.noMasksCache), 26936 Array.isArray(this.maskset.metadata)) { 26937 var e = l.getMaskTemplate.call(this, !0, 0, !1).join(""); 26938 return this.maskset.metadata.forEach((function(t) { 26939 return t.mask !== e || (e = t, !1); 26940 })), e; 26941 } 26942 return this.maskset.metadata; 26943 }, 26944 isValid: function(e) { 26945 if (this.maskset = this.maskset || (0, o.generateMaskSet)(this.opts, this.noMasksCache), 26946 e) { 26947 var t = ("function" == typeof this.opts.onBeforeMask && this.opts.onBeforeMask.call(this, e, this.opts) || e).split(""); 26948 c.checkVal.call(this, void 0, !0, !1, t); 26949 } else e = this.isRTL ? s.getBuffer.call(this).slice().reverse().join("") : s.getBuffer.call(this).join(""); 26950 for (var i = s.getBuffer.call(this), a = s.determineLastRequiredPosition.call(this), n = i.length - 1; n > a && !s.isMask.call(this, n); n--) ; 26951 return i.splice(a, n + 1 - a), u.isComplete.call(this, i) && e === (this.isRTL ? s.getBuffer.call(this).slice().reverse().join("") : s.getBuffer.call(this).join("")); 26952 }, 26953 format: function(e, t) { 26954 this.maskset = this.maskset || (0, o.generateMaskSet)(this.opts, this.noMasksCache); 26955 var i = ("function" == typeof this.opts.onBeforeMask && this.opts.onBeforeMask.call(this, e, this.opts) || e).split(""); 26956 c.checkVal.call(this, void 0, !0, !1, i); 26957 var a = this.isRTL ? s.getBuffer.call(this).slice().reverse().join("") : s.getBuffer.call(this).join(""); 26958 return t ? { 26959 value: a, 26960 metadata: this.getmetadata() 26961 } : a; 26962 }, 26963 setValue: function(e) { 26964 this.el && (0, n.default)(this.el).trigger("setvalue", [ e ]); 26965 }, 26966 analyseMask: o.analyseMask 26967 }, y.extendDefaults = function(e) { 26968 n.default.extend(!0, y.prototype.defaults, e); 26969 }, y.extendDefinitions = function(e) { 26970 n.default.extend(!0, y.prototype.definitions, e); 26971 }, y.extendAliases = function(e) { 26972 n.default.extend(!0, y.prototype.aliases, e); 26973 }, y.format = function(e, t, i) { 26974 return y(t).format(e, i); 26975 }, y.unmask = function(e, t) { 26976 return y(t).unmaskedvalue(e); 26977 }, y.isValid = function(e, t) { 26978 return y(t).isValid(e); 26979 }, y.remove = function(e) { 26980 "string" == typeof e && (e = g.getElementById(e) || g.querySelectorAll(e)), (e = e.nodeName ? [ e ] : e).forEach((function(e) { 26981 e.inputmask && e.inputmask.remove(); 26982 })); 26983 }, y.setValue = function(e, t) { 26984 "string" == typeof e && (e = g.getElementById(e) || g.querySelectorAll(e)), (e = e.nodeName ? [ e ] : e).forEach((function(e) { 26985 e.inputmask ? e.inputmask.setValue(t) : (0, n.default)(e).trigger("setvalue", [ t ]); 26986 })); 26987 }, y.dependencyLib = n.default, r.default.Inputmask = y; 26988 var x = y; 26989 t.default = x; 26990 }, 26991 5296: function(e, t, i) { 26992 function a(e) { 26993 return a = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) { 26994 return typeof e; 26995 } : function(e) { 26996 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e; 26997 }, a(e); 26998 } 26999 var n = h(i(9380)), r = h(i(2394)), o = h(i(8741)); 27000 function l(e, t) { 27001 for (var i = 0; i < t.length; i++) { 27002 var a = t[i]; 27003 a.enumerable = a.enumerable || !1, a.configurable = !0, "value" in a && (a.writable = !0), 27004 Object.defineProperty(e, a.key, a); 27005 } 27006 } 27007 function s(e, t) { 27008 if (t && ("object" === a(t) || "function" == typeof t)) return t; 27009 if (void 0 !== t) throw new TypeError("Derived constructors may only return object or undefined"); 27010 return function(e) { 27011 if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); 27012 return e; 27013 }(e); 27014 } 27015 function u(e) { 27016 var t = "function" == typeof Map ? new Map : void 0; 27017 return u = function(e) { 27018 if (null === e || (i = e, -1 === Function.toString.call(i).indexOf("[native code]"))) return e; 27019 var i; 27020 if ("function" != typeof e) throw new TypeError("Super expression must either be null or a function"); 27021 if (void 0 !== t) { 27022 if (t.has(e)) return t.get(e); 27023 t.set(e, a); 27024 } 27025 function a() { 27026 return c(e, arguments, p(this).constructor); 27027 } 27028 return a.prototype = Object.create(e.prototype, { 27029 constructor: { 27030 value: a, 27031 enumerable: !1, 27032 writable: !0, 27033 configurable: !0 27034 } 27035 }), d(a, e); 27036 }, u(e); 27037 } 27038 function c(e, t, i) { 27039 return c = f() ? Reflect.construct : function(e, t, i) { 27040 var a = [ null ]; 27041 a.push.apply(a, t); 27042 var n = new (Function.bind.apply(e, a)); 27043 return i && d(n, i.prototype), n; 27044 }, c.apply(null, arguments); 27045 } 27046 function f() { 27047 if ("undefined" == typeof Reflect || !Reflect.construct) return !1; 27048 if (Reflect.construct.sham) return !1; 27049 if ("function" == typeof Proxy) return !0; 27050 try { 27051 return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function() {}))), 27052 !0; 27053 } catch (e) { 27054 return !1; 27055 } 27056 } 27057 function d(e, t) { 27058 return d = Object.setPrototypeOf || function(e, t) { 27059 return e.__proto__ = t, e; 27060 }, d(e, t); 27061 } 27062 function p(e) { 27063 return p = Object.setPrototypeOf ? Object.getPrototypeOf : function(e) { 27064 return e.__proto__ || Object.getPrototypeOf(e); 27065 }, p(e); 27066 } 27067 function h(e) { 27068 return e && e.__esModule ? e : { 27069 default: e 27070 }; 27071 } 27072 var v = n.default.document; 27073 if (o.default && v && v.head && v.head.attachShadow && n.default.customElements && void 0 === n.default.customElements.get("input-mask")) { 27074 var m = function(e) { 27075 !function(e, t) { 27076 if ("function" != typeof t && null !== t) throw new TypeError("Super expression must either be null or a function"); 27077 Object.defineProperty(e, "prototype", { 27078 value: Object.create(t && t.prototype, { 27079 constructor: { 27080 value: e, 27081 writable: !0, 27082 configurable: !0 27083 } 27084 }), 27085 writable: !1 27086 }), t && d(e, t); 27087 }(c, e); 27088 var t, i, a, n, o, u = (t = c, i = f(), function() { 27089 var e, a = p(t); 27090 if (i) { 27091 var n = p(this).constructor; 27092 e = Reflect.construct(a, arguments, n); 27093 } else e = a.apply(this, arguments); 27094 return s(this, e); 27095 }); 27096 function c() { 27097 var e; 27098 !function(e, t) { 27099 if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function"); 27100 }(this, c); 27101 var t = (e = u.call(this)).getAttributeNames(), i = e.attachShadow({ 27102 mode: "closed" 27103 }), a = v.createElement("input"); 27104 for (var n in a.type = "text", i.appendChild(a), t) Object.prototype.hasOwnProperty.call(t, n) && a.setAttribute(t[n], e.getAttribute(t[n])); 27105 var o = new r.default; 27106 return o.dataAttribute = "", o.mask(a), a.inputmask.shadowRoot = i, e; 27107 } 27108 return a = c, n && l(a.prototype, n), o && l(a, o), Object.defineProperty(a, "prototype", { 27109 writable: !1 27110 }), a; 27111 }(u(HTMLElement)); 27112 n.default.customElements.define("input-mask", m); 27113 } 27114 }, 27115 2391: function(e, t, i) { 27116 Object.defineProperty(t, "__esModule", { 27117 value: !0 27118 }), t.analyseMask = function(e, t, i) { 27119 var a, o, l, s, u, c, f = /(?:[?*+]|\{[0-9+*]+(?:,[0-9+*]*)?(?:\|[0-9+*]*)?\})|[^.?*+^${[]()|\\]+|./g, d = /\[\^?]?(?:[^\\\]]+|\\[\S\s]?)*]?|\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9][0-9]*|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|c[A-Za-z]|[\S\s]?)|\((?:\?[:=!]?)?|(?:[?*+]|\{[0-9]+(?:,[0-9]*)?\})\??|[^.?*+^${[()|\\]+|./g, p = !1, h = new n.default, v = [], m = [], g = !1; 27120 function k(e, a, n) { 27121 n = void 0 !== n ? n : e.matches.length; 27122 var o = e.matches[n - 1]; 27123 if (t) 0 === a.indexOf("[") || p && /\\d|\\s|\\w/i.test(a) || "." === a ? e.matches.splice(n++, 0, { 27124 fn: new RegExp(a, i.casing ? "i" : ""), 27125 static: !1, 27126 optionality: !1, 27127 newBlockMarker: void 0 === o ? "master" : o.def !== a, 27128 casing: null, 27129 def: a, 27130 placeholder: void 0, 27131 nativeDef: a 27132 }) : (p && (a = a[a.length - 1]), a.split("").forEach((function(t, a) { 27133 o = e.matches[n - 1], e.matches.splice(n++, 0, { 27134 fn: /[a-z]/i.test(i.staticDefinitionSymbol || t) ? new RegExp("[" + (i.staticDefinitionSymbol || t) + "]", i.casing ? "i" : "") : null, 27135 static: !0, 27136 optionality: !1, 27137 newBlockMarker: void 0 === o ? "master" : o.def !== t && !0 !== o.static, 27138 casing: null, 27139 def: i.staticDefinitionSymbol || t, 27140 placeholder: void 0 !== i.staticDefinitionSymbol ? t : void 0, 27141 nativeDef: (p ? "'" : "") + t 27142 }); 27143 }))), p = !1; else { 27144 var l = i.definitions && i.definitions[a] || i.usePrototypeDefinitions && r.default.prototype.definitions[a]; 27145 l && !p ? e.matches.splice(n++, 0, { 27146 fn: l.validator ? "string" == typeof l.validator ? new RegExp(l.validator, i.casing ? "i" : "") : new function() { 27147 this.test = l.validator; 27148 } : new RegExp("."), 27149 static: l.static || !1, 27150 optionality: l.optional || !1, 27151 newBlockMarker: void 0 === o || l.optional ? "master" : o.def !== (l.definitionSymbol || a), 27152 casing: l.casing, 27153 def: l.definitionSymbol || a, 27154 placeholder: l.placeholder, 27155 nativeDef: a, 27156 generated: l.generated 27157 }) : (e.matches.splice(n++, 0, { 27158 fn: /[a-z]/i.test(i.staticDefinitionSymbol || a) ? new RegExp("[" + (i.staticDefinitionSymbol || a) + "]", i.casing ? "i" : "") : null, 27159 static: !0, 27160 optionality: !1, 27161 newBlockMarker: void 0 === o ? "master" : o.def !== a && !0 !== o.static, 27162 casing: null, 27163 def: i.staticDefinitionSymbol || a, 27164 placeholder: void 0 !== i.staticDefinitionSymbol ? a : void 0, 27165 nativeDef: (p ? "'" : "") + a 27166 }), p = !1); 27167 } 27168 } 27169 function y() { 27170 if (v.length > 0) { 27171 if (k(s = v[v.length - 1], o), s.isAlternator) { 27172 u = v.pop(); 27173 for (var e = 0; e < u.matches.length; e++) u.matches[e].isGroup && (u.matches[e].isGroup = !1); 27174 v.length > 0 ? (s = v[v.length - 1]).matches.push(u) : h.matches.push(u); 27175 } 27176 } else k(h, o); 27177 } 27178 function b(e) { 27179 var t = new n.default(!0); 27180 return t.openGroup = !1, t.matches = e, t; 27181 } 27182 function x() { 27183 if ((l = v.pop()).openGroup = !1, void 0 !== l) if (v.length > 0) { 27184 if ((s = v[v.length - 1]).matches.push(l), s.isAlternator) { 27185 for (var e = (u = v.pop()).matches[0].matches ? u.matches[0].matches.length : 1, t = 0; t < u.matches.length; t++) u.matches[t].isGroup = !1, 27186 u.matches[t].alternatorGroup = !1, null === i.keepStatic && e < (u.matches[t].matches ? u.matches[t].matches.length : 1) && (i.keepStatic = !0), 27187 e = u.matches[t].matches ? u.matches[t].matches.length : 1; 27188 v.length > 0 ? (s = v[v.length - 1]).matches.push(u) : h.matches.push(u); 27189 } 27190 } else h.matches.push(l); else y(); 27191 } 27192 function P(e) { 27193 var t = e.pop(); 27194 return t.isQuantifier && (t = b([ e.pop(), t ])), t; 27195 } 27196 t && (i.optionalmarker[0] = void 0, i.optionalmarker[1] = void 0); 27197 for (;a = t ? d.exec(e) : f.exec(e); ) { 27198 if (o = a[0], t) { 27199 switch (o.charAt(0)) { 27200 case "?": 27201 o = "{0,1}"; 27202 break; 27203 27204 case "+": 27205 case "*": 27206 o = "{" + o + "}"; 27207 break; 27208 27209 case "|": 27210 if (0 === v.length) { 27211 var E = b(h.matches); 27212 E.openGroup = !0, v.push(E), h.matches = [], g = !0; 27213 } 27214 } 27215 if ("\\d" === o) o = "[0-9]"; 27216 } 27217 if (p) y(); else switch (o.charAt(0)) { 27218 case "$": 27219 case "^": 27220 t || y(); 27221 break; 27222 27223 case i.escapeChar: 27224 p = !0, t && y(); 27225 break; 27226 27227 case i.optionalmarker[1]: 27228 case i.groupmarker[1]: 27229 x(); 27230 break; 27231 27232 case i.optionalmarker[0]: 27233 v.push(new n.default(!1, !0)); 27234 break; 27235 27236 case i.groupmarker[0]: 27237 v.push(new n.default(!0)); 27238 break; 27239 27240 case i.quantifiermarker[0]: 27241 var S = new n.default(!1, !1, !0), _ = (o = o.replace(/[{}?]/g, "")).split("|"), w = _[0].split(","), M = isNaN(w[0]) ? w[0] : parseInt(w[0]), O = 1 === w.length ? M : isNaN(w[1]) ? w[1] : parseInt(w[1]), T = isNaN(_[1]) ? _[1] : parseInt(_[1]); 27242 "*" !== M && "+" !== M || (M = "*" === O ? 0 : 1), S.quantifier = { 27243 min: M, 27244 max: O, 27245 jit: T 27246 }; 27247 var C = v.length > 0 ? v[v.length - 1].matches : h.matches; 27248 if ((a = C.pop()).isAlternator) { 27249 C.push(a), C = a.matches; 27250 var A = new n.default(!0), D = C.pop(); 27251 C.push(A), C = A.matches, a = D; 27252 } 27253 a.isGroup || (a = b([ a ])), C.push(a), C.push(S); 27254 break; 27255 27256 case i.alternatormarker: 27257 if (v.length > 0) { 27258 var j = (s = v[v.length - 1]).matches[s.matches.length - 1]; 27259 c = s.openGroup && (void 0 === j.matches || !1 === j.isGroup && !1 === j.isAlternator) ? v.pop() : P(s.matches); 27260 } else c = P(h.matches); 27261 if (c.isAlternator) v.push(c); else if (c.alternatorGroup ? (u = v.pop(), c.alternatorGroup = !1) : u = new n.default(!1, !1, !1, !0), 27262 u.matches.push(c), v.push(u), c.openGroup) { 27263 c.openGroup = !1; 27264 var B = new n.default(!0); 27265 B.alternatorGroup = !0, v.push(B); 27266 } 27267 break; 27268 27269 default: 27270 y(); 27271 } 27272 } 27273 g && x(); 27274 for (;v.length > 0; ) l = v.pop(), h.matches.push(l); 27275 h.matches.length > 0 && (!function e(a) { 27276 a && a.matches && a.matches.forEach((function(n, r) { 27277 var o = a.matches[r + 1]; 27278 (void 0 === o || void 0 === o.matches || !1 === o.isQuantifier) && n && n.isGroup && (n.isGroup = !1, 27279 t || (k(n, i.groupmarker[0], 0), !0 !== n.openGroup && k(n, i.groupmarker[1]))), 27280 e(n); 27281 })); 27282 }(h), m.push(h)); 27283 (i.numericInput || i.isRTL) && function e(t) { 27284 for (var a in t.matches = t.matches.reverse(), t.matches) if (Object.prototype.hasOwnProperty.call(t.matches, a)) { 27285 var n = parseInt(a); 27286 if (t.matches[a].isQuantifier && t.matches[n + 1] && t.matches[n + 1].isGroup) { 27287 var r = t.matches[a]; 27288 t.matches.splice(a, 1), t.matches.splice(n + 1, 0, r); 27289 } 27290 void 0 !== t.matches[a].matches ? t.matches[a] = e(t.matches[a]) : t.matches[a] = ((o = t.matches[a]) === i.optionalmarker[0] ? o = i.optionalmarker[1] : o === i.optionalmarker[1] ? o = i.optionalmarker[0] : o === i.groupmarker[0] ? o = i.groupmarker[1] : o === i.groupmarker[1] && (o = i.groupmarker[0]), 27291 o); 27292 } 27293 var o; 27294 return t; 27295 }(m[0]); 27296 return m; 27297 }, t.generateMaskSet = function(e, t) { 27298 var i; 27299 function n(e, i, n) { 27300 var o, l, s = !1; 27301 if (null !== e && "" !== e || ((s = null !== n.regex) ? e = (e = n.regex).replace(/^(\^)(.*)(\$)$/, "$2") : (s = !0, 27302 e = ".*")), 1 === e.length && !1 === n.greedy && 0 !== n.repeat && (n.placeholder = ""), 27303 n.repeat > 0 || "*" === n.repeat || "+" === n.repeat) { 27304 var u = "*" === n.repeat ? 0 : "+" === n.repeat ? 1 : n.repeat; 27305 e = n.groupmarker[0] + e + n.groupmarker[1] + n.quantifiermarker[0] + u + "," + n.repeat + n.quantifiermarker[1]; 27306 } 27307 return l = s ? "regex_" + n.regex : n.numericInput ? e.split("").reverse().join("") : e, 27308 null !== n.keepStatic && (l = "ks_" + n.keepStatic + l), void 0 === r.default.prototype.masksCache[l] || !0 === t ? (o = { 27309 mask: e, 27310 maskToken: r.default.prototype.analyseMask(e, s, n), 27311 validPositions: {}, 27312 _buffer: void 0, 27313 buffer: void 0, 27314 tests: {}, 27315 excludes: {}, 27316 metadata: i, 27317 maskLength: void 0, 27318 jitOffset: {} 27319 }, !0 !== t && (r.default.prototype.masksCache[l] = o, o = a.default.extend(!0, {}, r.default.prototype.masksCache[l]))) : o = a.default.extend(!0, {}, r.default.prototype.masksCache[l]), 27320 o; 27321 } 27322 "function" == typeof e.mask && (e.mask = e.mask(e)); 27323 if (Array.isArray(e.mask)) { 27324 if (e.mask.length > 1) { 27325 null === e.keepStatic && (e.keepStatic = !0); 27326 var o = e.groupmarker[0]; 27327 return (e.isRTL ? e.mask.reverse() : e.mask).forEach((function(t) { 27328 o.length > 1 && (o += e.alternatormarker), void 0 !== t.mask && "function" != typeof t.mask ? o += t.mask : o += t; 27329 })), n(o += e.groupmarker[1], e.mask, e); 27330 } 27331 e.mask = e.mask.pop(); 27332 } 27333 i = e.mask && void 0 !== e.mask.mask && "function" != typeof e.mask.mask ? n(e.mask.mask, e.mask, e) : n(e.mask, e.mask, e); 27334 null === e.keepStatic && (e.keepStatic = !1); 27335 return i; 27336 }; 27337 var a = o(i(4963)), n = o(i(9695)), r = o(i(2394)); 27338 function o(e) { 27339 return e && e.__esModule ? e : { 27340 default: e 27341 }; 27342 } 27343 }, 27344 157: function(e, t, i) { 27345 Object.defineProperty(t, "__esModule", { 27346 value: !0 27347 }), t.mask = function() { 27348 var e = this, t = this.opts, i = this.el, a = this.dependencyLib; 27349 l.EventRuler.off(i); 27350 var f = function(t, i) { 27351 "textarea" !== t.tagName.toLowerCase() && i.ignorables.push(n.default.ENTER); 27352 var s = t.getAttribute("type"), u = "input" === t.tagName.toLowerCase() && i.supportsInputType.includes(s) || t.isContentEditable || "textarea" === t.tagName.toLowerCase(); 27353 if (!u) if ("input" === t.tagName.toLowerCase()) { 27354 var c = document.createElement("input"); 27355 c.setAttribute("type", s), u = "text" === c.type, c = null; 27356 } else u = "partial"; 27357 return !1 !== u ? function(t) { 27358 var n, s; 27359 function u() { 27360 return this.inputmask ? this.inputmask.opts.autoUnmask ? this.inputmask.unmaskedvalue() : -1 !== r.getLastValidPosition.call(e) || !0 !== i.nullable ? (this.inputmask.shadowRoot || this.ownerDocument).activeElement === this && i.clearMaskOnLostFocus ? (e.isRTL ? o.clearOptionalTail.call(e, r.getBuffer.call(e).slice()).reverse() : o.clearOptionalTail.call(e, r.getBuffer.call(e).slice())).join("") : n.call(this) : "" : n.call(this); 27361 } 27362 function c(e) { 27363 s.call(this, e), this.inputmask && (0, o.applyInputValue)(this, e); 27364 } 27365 if (!t.inputmask.__valueGet) { 27366 if (!0 !== i.noValuePatching) { 27367 if (Object.getOwnPropertyDescriptor) { 27368 var f = Object.getPrototypeOf ? Object.getOwnPropertyDescriptor(Object.getPrototypeOf(t), "value") : void 0; 27369 f && f.get && f.set ? (n = f.get, s = f.set, Object.defineProperty(t, "value", { 27370 get: u, 27371 set: c, 27372 configurable: !0 27373 })) : "input" !== t.tagName.toLowerCase() && (n = function() { 27374 return this.textContent; 27375 }, s = function(e) { 27376 this.textContent = e; 27377 }, Object.defineProperty(t, "value", { 27378 get: u, 27379 set: c, 27380 configurable: !0 27381 })); 27382 } else document.__lookupGetter__ && t.__lookupGetter__("value") && (n = t.__lookupGetter__("value"), 27383 s = t.__lookupSetter__("value"), t.__defineGetter__("value", u), t.__defineSetter__("value", c)); 27384 t.inputmask.__valueGet = n, t.inputmask.__valueSet = s; 27385 } 27386 t.inputmask._valueGet = function(t) { 27387 return e.isRTL && !0 !== t ? n.call(this.el).split("").reverse().join("") : n.call(this.el); 27388 }, t.inputmask._valueSet = function(t, i) { 27389 s.call(this.el, null == t ? "" : !0 !== i && e.isRTL ? t.split("").reverse().join("") : t); 27390 }, void 0 === n && (n = function() { 27391 return this.value; 27392 }, s = function(e) { 27393 this.value = e; 27394 }, function(t) { 27395 if (a.valHooks && (void 0 === a.valHooks[t] || !0 !== a.valHooks[t].inputmaskpatch)) { 27396 var n = a.valHooks[t] && a.valHooks[t].get ? a.valHooks[t].get : function(e) { 27397 return e.value; 27398 }, l = a.valHooks[t] && a.valHooks[t].set ? a.valHooks[t].set : function(e, t) { 27399 return e.value = t, e; 27400 }; 27401 a.valHooks[t] = { 27402 get: function(t) { 27403 if (t.inputmask) { 27404 if (t.inputmask.opts.autoUnmask) return t.inputmask.unmaskedvalue(); 27405 var a = n(t); 27406 return -1 !== r.getLastValidPosition.call(e, void 0, void 0, t.inputmask.maskset.validPositions) || !0 !== i.nullable ? a : ""; 27407 } 27408 return n(t); 27409 }, 27410 set: function(e, t) { 27411 var i = l(e, t); 27412 return e.inputmask && (0, o.applyInputValue)(e, t), i; 27413 }, 27414 inputmaskpatch: !0 27415 }; 27416 } 27417 }(t.type), function(t) { 27418 l.EventRuler.on(t, "mouseenter", (function() { 27419 var t = this.inputmask._valueGet(!0); 27420 t !== (e.isRTL ? r.getBuffer.call(e).reverse() : r.getBuffer.call(e)).join("") && (0, 27421 o.applyInputValue)(this, t); 27422 })); 27423 }(t)); 27424 } 27425 }(t) : t.inputmask = void 0, u; 27426 }(i, t); 27427 if (!1 !== f) { 27428 e.originalPlaceholder = i.placeholder, e.maxLength = void 0 !== i ? i.maxLength : void 0, 27429 -1 === e.maxLength && (e.maxLength = void 0), "inputMode" in i && null === i.getAttribute("inputmode") && (i.inputMode = t.inputmode, 27430 i.setAttribute("inputmode", t.inputmode)), !0 === f && (t.showMaskOnFocus = t.showMaskOnFocus && -1 === [ "cc-number", "cc-exp" ].indexOf(i.autocomplete), 27431 s.iphone && (t.insertModeVisual = !1), l.EventRuler.on(i, "submit", c.EventHandlers.submitEvent), 27432 l.EventRuler.on(i, "reset", c.EventHandlers.resetEvent), l.EventRuler.on(i, "blur", c.EventHandlers.blurEvent), 27433 l.EventRuler.on(i, "focus", c.EventHandlers.focusEvent), l.EventRuler.on(i, "invalid", c.EventHandlers.invalidEvent), 27434 l.EventRuler.on(i, "click", c.EventHandlers.clickEvent), l.EventRuler.on(i, "mouseleave", c.EventHandlers.mouseleaveEvent), 27435 l.EventRuler.on(i, "mouseenter", c.EventHandlers.mouseenterEvent), l.EventRuler.on(i, "paste", c.EventHandlers.pasteEvent), 27436 l.EventRuler.on(i, "cut", c.EventHandlers.cutEvent), l.EventRuler.on(i, "complete", t.oncomplete), 27437 l.EventRuler.on(i, "incomplete", t.onincomplete), l.EventRuler.on(i, "cleared", t.oncleared), 27438 !0 !== t.inputEventOnly && (l.EventRuler.on(i, "keydown", c.EventHandlers.keydownEvent), 27439 l.EventRuler.on(i, "keypress", c.EventHandlers.keypressEvent), l.EventRuler.on(i, "keyup", c.EventHandlers.keyupEvent)), 27440 (s.mobile || t.inputEventOnly) && i.removeAttribute("maxLength"), l.EventRuler.on(i, "input", c.EventHandlers.inputFallBackEvent), 27441 l.EventRuler.on(i, "compositionend", c.EventHandlers.compositionendEvent)), l.EventRuler.on(i, "setvalue", c.EventHandlers.setValueEvent), 27442 r.getBufferTemplate.call(e).join(""), e.undoValue = e._valueGet(!0); 27443 var d = (i.inputmask.shadowRoot || i.ownerDocument).activeElement; 27444 if ("" !== i.inputmask._valueGet(!0) || !1 === t.clearMaskOnLostFocus || d === i) { 27445 (0, o.applyInputValue)(i, i.inputmask._valueGet(!0), t); 27446 var p = r.getBuffer.call(e).slice(); 27447 !1 === u.isComplete.call(e, p) && t.clearIncomplete && r.resetMaskSet.call(e), t.clearMaskOnLostFocus && d !== i && (-1 === r.getLastValidPosition.call(e) ? p = [] : o.clearOptionalTail.call(e, p)), 27448 (!1 === t.clearMaskOnLostFocus || t.showMaskOnFocus && d === i || "" !== i.inputmask._valueGet(!0)) && (0, 27449 o.writeBuffer)(i, p), d === i && r.caret.call(e, i, r.seekNext.call(e, r.getLastValidPosition.call(e))); 27450 } 27451 } 27452 }; 27453 var a, n = (a = i(5581)) && a.__esModule ? a : { 27454 default: a 27455 }, r = i(8711), o = i(7760), l = i(9716), s = i(9845), u = i(7215), c = i(6030); 27456 }, 27457 9695: function(e, t) { 27458 Object.defineProperty(t, "__esModule", { 27459 value: !0 27460 }), t.default = function(e, t, i, a) { 27461 this.matches = [], this.openGroup = e || !1, this.alternatorGroup = !1, this.isGroup = e || !1, 27462 this.isOptional = t || !1, this.isQuantifier = i || !1, this.isAlternator = a || !1, 27463 this.quantifier = { 27464 min: 1, 27465 max: 1 27466 }; 27467 }; 27468 }, 27469 3194: function() { 27470 Array.prototype.includes || Object.defineProperty(Array.prototype, "includes", { 27471 value: function(e, t) { 27472 if (null == this) throw new TypeError('"this" is null or not defined'); 27473 var i = Object(this), a = i.length >>> 0; 27474 if (0 === a) return !1; 27475 for (var n = 0 | t, r = Math.max(n >= 0 ? n : a - Math.abs(n), 0); r < a; ) { 27476 if (i[r] === e) return !0; 27477 r++; 27478 } 27479 return !1; 27480 } 27481 }); 27482 }, 27483 7149: function() { 27484 function e(t) { 27485 return e = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) { 27486 return typeof e; 27487 } : function(e) { 27488 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e; 27489 }, e(t); 27490 } 27491 "function" != typeof Object.getPrototypeOf && (Object.getPrototypeOf = "object" === e("test".__proto__) ? function(e) { 27492 return e.__proto__; 27493 } : function(e) { 27494 return e.constructor.prototype; 27495 }); 27496 }, 27497 8711: function(e, t, i) { 27498 Object.defineProperty(t, "__esModule", { 27499 value: !0 27500 }), t.caret = function(e, t, i, a, n) { 27501 var r, o = this, l = this.opts; 27502 if (void 0 === t) return "selectionStart" in e && "selectionEnd" in e ? (t = e.selectionStart, 27503 i = e.selectionEnd) : window.getSelection ? (r = window.getSelection().getRangeAt(0)).commonAncestorContainer.parentNode !== e && r.commonAncestorContainer !== e || (t = r.startOffset, 27504 i = r.endOffset) : document.selection && document.selection.createRange && (r = document.selection.createRange(), 27505 t = 0 - r.duplicate().moveStart("character", -e.inputmask._valueGet().length), i = t + r.text.length), 27506 { 27507 begin: a ? t : u.call(o, t), 27508 end: a ? i : u.call(o, i) 27509 }; 27510 if (Array.isArray(t) && (i = o.isRTL ? t[0] : t[1], t = o.isRTL ? t[1] : t[0]), 27511 void 0 !== t.begin && (i = o.isRTL ? t.begin : t.end, t = o.isRTL ? t.end : t.begin), 27512 "number" == typeof t) { 27513 t = a ? t : u.call(o, t), i = "number" == typeof (i = a ? i : u.call(o, i)) ? i : t; 27514 var s = parseInt(((e.ownerDocument.defaultView || window).getComputedStyle ? (e.ownerDocument.defaultView || window).getComputedStyle(e, null) : e.currentStyle).fontSize) * i; 27515 if (e.scrollLeft = s > e.scrollWidth ? s : 0, e.inputmask.caretPos = { 27516 begin: t, 27517 end: i 27518 }, l.insertModeVisual && !1 === l.insertMode && t === i && (n || i++), e === (e.inputmask.shadowRoot || e.ownerDocument).activeElement) if ("setSelectionRange" in e) e.setSelectionRange(t, i); else if (window.getSelection) { 27519 if (r = document.createRange(), void 0 === e.firstChild || null === e.firstChild) { 27520 var c = document.createTextNode(""); 27521 e.appendChild(c); 27522 } 27523 r.setStart(e.firstChild, t < e.inputmask._valueGet().length ? t : e.inputmask._valueGet().length), 27524 r.setEnd(e.firstChild, i < e.inputmask._valueGet().length ? i : e.inputmask._valueGet().length), 27525 r.collapse(!0); 27526 var f = window.getSelection(); 27527 f.removeAllRanges(), f.addRange(r); 27528 } else e.createTextRange && ((r = e.createTextRange()).collapse(!0), r.moveEnd("character", i), 27529 r.moveStart("character", t), r.select()); 27530 } 27531 }, t.determineLastRequiredPosition = function(e) { 27532 var t, i, r = this, l = this.maskset, s = this.dependencyLib, u = a.getMaskTemplate.call(r, !0, o.call(r), !0, !0), c = u.length, f = o.call(r), d = {}, p = l.validPositions[f], h = void 0 !== p ? p.locator.slice() : void 0; 27533 for (t = f + 1; t < u.length; t++) i = a.getTestTemplate.call(r, t, h, t - 1), h = i.locator.slice(), 27534 d[t] = s.extend(!0, {}, i); 27535 var v = p && void 0 !== p.alternation ? p.locator[p.alternation] : void 0; 27536 for (t = c - 1; t > f && (((i = d[t]).match.optionality || i.match.optionalQuantifier && i.match.newBlockMarker || v && (v !== d[t].locator[p.alternation] && 1 != i.match.static || !0 === i.match.static && i.locator[p.alternation] && n.checkAlternationMatch.call(r, i.locator[p.alternation].toString().split(","), v.toString().split(",")) && "" !== a.getTests.call(r, t)[0].def)) && u[t] === a.getPlaceholder.call(r, t, i.match)); t--) c--; 27537 return e ? { 27538 l: c, 27539 def: d[c] ? d[c].match : void 0 27540 } : c; 27541 }, t.determineNewCaretPosition = function(e, t, i) { 27542 var n = this, u = this.maskset, c = this.opts; 27543 t && (n.isRTL ? e.end = e.begin : e.begin = e.end); 27544 if (e.begin === e.end) { 27545 switch (i = i || c.positionCaretOnClick) { 27546 case "none": 27547 break; 27548 27549 case "select": 27550 e = { 27551 begin: 0, 27552 end: r.call(n).length 27553 }; 27554 break; 27555 27556 case "ignore": 27557 e.end = e.begin = s.call(n, o.call(n)); 27558 break; 27559 27560 case "radixFocus": 27561 if (function(e) { 27562 if ("" !== c.radixPoint && 0 !== c.digits) { 27563 var t = u.validPositions; 27564 if (void 0 === t[e] || t[e].input === a.getPlaceholder.call(n, e)) { 27565 if (e < s.call(n, -1)) return !0; 27566 var i = r.call(n).indexOf(c.radixPoint); 27567 if (-1 !== i) { 27568 for (var o in t) if (t[o] && i < o && t[o].input !== a.getPlaceholder.call(n, o)) return !1; 27569 return !0; 27570 } 27571 } 27572 } 27573 return !1; 27574 }(e.begin)) { 27575 var f = r.call(n).join("").indexOf(c.radixPoint); 27576 e.end = e.begin = c.numericInput ? s.call(n, f) : f; 27577 break; 27578 } 27579 27580 default: 27581 var d = e.begin, p = o.call(n, d, !0), h = s.call(n, -1 !== p || l.call(n, 0) ? p : -1); 27582 if (d <= h) e.end = e.begin = l.call(n, d, !1, !0) ? d : s.call(n, d); else { 27583 var v = u.validPositions[p], m = a.getTestTemplate.call(n, h, v ? v.match.locator : void 0, v), g = a.getPlaceholder.call(n, h, m.match); 27584 if ("" !== g && r.call(n)[h] !== g && !0 !== m.match.optionalQuantifier && !0 !== m.match.newBlockMarker || !l.call(n, h, c.keepStatic, !0) && m.match.def === g) { 27585 var k = s.call(n, h); 27586 (d >= k || d === h) && (h = k); 27587 } 27588 e.end = e.begin = h; 27589 } 27590 } 27591 return e; 27592 } 27593 }, t.getBuffer = r, t.getBufferTemplate = function() { 27594 var e = this.maskset; 27595 void 0 === e._buffer && (e._buffer = a.getMaskTemplate.call(this, !1, 1), void 0 === e.buffer && (e.buffer = e._buffer.slice())); 27596 return e._buffer; 27597 }, t.getLastValidPosition = o, t.isMask = l, t.resetMaskSet = function(e) { 27598 var t = this.maskset; 27599 t.buffer = void 0, !0 !== e && (t.validPositions = {}, t.p = 0); 27600 }, t.seekNext = s, t.seekPrevious = function(e, t) { 27601 var i = this, n = e - 1; 27602 if (e <= 0) return 0; 27603 for (;n > 0 && (!0 === t && (!0 !== a.getTest.call(i, n).match.newBlockMarker || !l.call(i, n, void 0, !0)) || !0 !== t && !l.call(i, n, void 0, !0)); ) n--; 27604 return n; 27605 }, t.translatePosition = u; 27606 var a = i(4713), n = i(7215); 27607 function r(e) { 27608 var t = this.maskset; 27609 return void 0 !== t.buffer && !0 !== e || (t.buffer = a.getMaskTemplate.call(this, !0, o.call(this), !0), 27610 void 0 === t._buffer && (t._buffer = t.buffer.slice())), t.buffer; 27611 } 27612 function o(e, t, i) { 27613 var a = this.maskset, n = -1, r = -1, o = i || a.validPositions; 27614 for (var l in void 0 === e && (e = -1), o) { 27615 var s = parseInt(l); 27616 o[s] && (t || !0 !== o[s].generatedInput) && (s <= e && (n = s), s >= e && (r = s)); 27617 } 27618 return -1 === n || n == e ? r : -1 == r || e - n < r - e ? n : r; 27619 } 27620 function l(e, t, i) { 27621 var n = this, r = this.maskset, o = a.getTestTemplate.call(n, e).match; 27622 if ("" === o.def && (o = a.getTest.call(n, e).match), !0 !== o.static) return o.fn; 27623 if (!0 === i && void 0 !== r.validPositions[e] && !0 !== r.validPositions[e].generatedInput) return !0; 27624 if (!0 !== t && e > -1) { 27625 if (i) { 27626 var l = a.getTests.call(n, e); 27627 return l.length > 1 + ("" === l[l.length - 1].match.def ? 1 : 0); 27628 } 27629 var s = a.determineTestTemplate.call(n, e, a.getTests.call(n, e)), u = a.getPlaceholder.call(n, e, s.match); 27630 return s.match.def !== u; 27631 } 27632 return !1; 27633 } 27634 function s(e, t, i) { 27635 var n = this; 27636 void 0 === i && (i = !0); 27637 for (var r = e + 1; "" !== a.getTest.call(n, r).match.def && (!0 === t && (!0 !== a.getTest.call(n, r).match.newBlockMarker || !l.call(n, r, void 0, !0)) || !0 !== t && !l.call(n, r, void 0, i)); ) r++; 27638 return r; 27639 } 27640 function u(e) { 27641 var t = this.opts, i = this.el; 27642 return !this.isRTL || "number" != typeof e || t.greedy && "" === t.placeholder || !i || (e = Math.abs(this._valueGet().length - e)), 27643 e; 27644 } 27645 }, 27646 4713: function(e, t, i) { 27647 Object.defineProperty(t, "__esModule", { 27648 value: !0 27649 }), t.determineTestTemplate = u, t.getDecisionTaker = o, t.getMaskTemplate = function(e, t, i, a, n) { 27650 var r = this, o = this.opts, c = this.maskset, f = o.greedy; 27651 n && o.greedy && (o.greedy = !1, r.maskset.tests = {}); 27652 t = t || 0; 27653 var p, h, v, m, g = [], k = 0; 27654 do { 27655 if (!0 === e && c.validPositions[k]) v = n && c.validPositions[k].match.optionality && void 0 === c.validPositions[k + 1] && (!0 === c.validPositions[k].generatedInput || c.validPositions[k].input == o.skipOptionalPartCharacter && k > 0) ? u.call(r, k, d.call(r, k, p, k - 1)) : c.validPositions[k], 27656 h = v.match, p = v.locator.slice(), g.push(!0 === i ? v.input : !1 === i ? h.nativeDef : l.call(r, k, h)); else { 27657 v = s.call(r, k, p, k - 1), h = v.match, p = v.locator.slice(); 27658 var y = !0 !== a && (!1 !== o.jitMasking ? o.jitMasking : h.jit); 27659 (m = (m && h.static && h.def !== o.groupSeparator && null === h.fn || c.validPositions[k - 1] && h.static && h.def !== o.groupSeparator && null === h.fn) && c.tests[k] && 1 === c.tests[k].length) || !1 === y || void 0 === y || "number" == typeof y && isFinite(y) && y > k ? g.push(!1 === i ? h.nativeDef : l.call(r, k, h)) : m = !1; 27660 } 27661 k++; 27662 } while (!0 !== h.static || "" !== h.def || t > k); 27663 "" === g[g.length - 1] && g.pop(); 27664 !1 === i && void 0 !== c.maskLength || (c.maskLength = k - 1); 27665 return o.greedy = f, g; 27666 }, t.getPlaceholder = l, t.getTest = c, t.getTestTemplate = s, t.getTests = d, t.isSubsetOf = f; 27667 var a, n = (a = i(2394)) && a.__esModule ? a : { 27668 default: a 27669 }; 27670 function r(e, t) { 27671 var i = (null != e.alternation ? e.mloc[o(e)] : e.locator).join(""); 27672 if ("" !== i) for (;i.length < t; ) i += "0"; 27673 return i; 27674 } 27675 function o(e) { 27676 var t = e.locator[e.alternation]; 27677 return "string" == typeof t && t.length > 0 && (t = t.split(",")[0]), void 0 !== t ? t.toString() : ""; 27678 } 27679 function l(e, t, i) { 27680 var a = this.opts, n = this.maskset; 27681 if (void 0 !== (t = t || c.call(this, e).match).placeholder || !0 === i) return "function" == typeof t.placeholder ? t.placeholder(a) : t.placeholder; 27682 if (!0 === t.static) { 27683 if (e > -1 && void 0 === n.validPositions[e]) { 27684 var r, o = d.call(this, e), l = []; 27685 if (o.length > 1 + ("" === o[o.length - 1].match.def ? 1 : 0)) for (var s = 0; s < o.length; s++) if ("" !== o[s].match.def && !0 !== o[s].match.optionality && !0 !== o[s].match.optionalQuantifier && (!0 === o[s].match.static || void 0 === r || !1 !== o[s].match.fn.test(r.match.def, n, e, !0, a)) && (l.push(o[s]), 27686 !0 === o[s].match.static && (r = o[s]), l.length > 1 && /[0-9a-bA-Z]/.test(l[0].match.def))) return a.placeholder.charAt(e % a.placeholder.length); 27687 } 27688 return t.def; 27689 } 27690 return a.placeholder.charAt(e % a.placeholder.length); 27691 } 27692 function s(e, t, i) { 27693 return this.maskset.validPositions[e] || u.call(this, e, d.call(this, e, t ? t.slice() : t, i)); 27694 } 27695 function u(e, t) { 27696 var i = this.opts, a = function(e, t) { 27697 var i = 0, a = !1; 27698 t.forEach((function(e) { 27699 e.match.optionality && (0 !== i && i !== e.match.optionality && (a = !0), (0 === i || i > e.match.optionality) && (i = e.match.optionality)); 27700 })), i && (0 == e || 1 == t.length ? i = 0 : a || (i = 0)); 27701 return i; 27702 }(e, t); 27703 e = e > 0 ? e - 1 : 0; 27704 var n, o, l, s = r(c.call(this, e)); 27705 i.greedy && t.length > 1 && "" === t[t.length - 1].match.def && t.pop(); 27706 for (var u = 0; u < t.length; u++) { 27707 var f = t[u]; 27708 n = r(f, s.length); 27709 var d = Math.abs(n - s); 27710 (void 0 === o || "" !== n && d < o || l && !i.greedy && l.match.optionality && l.match.optionality - a > 0 && "master" === l.match.newBlockMarker && (!f.match.optionality || f.match.optionality - a < 1 || !f.match.newBlockMarker) || l && !i.greedy && l.match.optionalQuantifier && !f.match.optionalQuantifier) && (o = d, 27711 l = f); 27712 } 27713 return l; 27714 } 27715 function c(e, t) { 27716 var i = this.maskset; 27717 return i.validPositions[e] ? i.validPositions[e] : (t || d.call(this, e))[0]; 27718 } 27719 function f(e, t, i) { 27720 function a(e) { 27721 for (var t, i = [], a = -1, n = 0, r = e.length; n < r; n++) if ("-" === e.charAt(n)) for (t = e.charCodeAt(n + 1); ++a < t; ) i.push(String.fromCharCode(a)); else a = e.charCodeAt(n), 27722 i.push(e.charAt(n)); 27723 return i.join(""); 27724 } 27725 return e.match.def === t.match.nativeDef || !(!(i.regex || e.match.fn instanceof RegExp && t.match.fn instanceof RegExp) || !0 === e.match.static || !0 === t.match.static) && -1 !== a(t.match.fn.toString().replace(/[[\]/]/g, "")).indexOf(a(e.match.fn.toString().replace(/[[\]/]/g, ""))); 27726 } 27727 function d(e, t, i) { 27728 var a, r, o = this, l = this.dependencyLib, s = this.maskset, c = this.opts, d = this.el, p = s.maskToken, h = t ? i : 0, v = t ? t.slice() : [ 0 ], m = [], g = !1, k = t ? t.join("") : ""; 27729 function y(t, i, r, o) { 27730 function l(r, o, u) { 27731 function p(e, t) { 27732 var i = 0 === t.matches.indexOf(e); 27733 return i || t.matches.every((function(a, n) { 27734 return !0 === a.isQuantifier ? i = p(e, t.matches[n - 1]) : Object.prototype.hasOwnProperty.call(a, "matches") && (i = p(e, a)), 27735 !i; 27736 })), i; 27737 } 27738 function v(e, t, i) { 27739 var a, n; 27740 if ((s.tests[e] || s.validPositions[e]) && (s.tests[e] || [ s.validPositions[e] ]).every((function(e, r) { 27741 if (e.mloc[t]) return a = e, !1; 27742 var o = void 0 !== i ? i : e.alternation, l = void 0 !== e.locator[o] ? e.locator[o].toString().indexOf(t) : -1; 27743 return (void 0 === n || l < n) && -1 !== l && (a = e, n = l), !0; 27744 })), a) { 27745 var r = a.locator[a.alternation]; 27746 return (a.mloc[t] || a.mloc[r] || a.locator).slice((void 0 !== i ? i : a.alternation) + 1); 27747 } 27748 return void 0 !== i ? v(e, t) : void 0; 27749 } 27750 function b(e, t) { 27751 var i = e.alternation, a = void 0 === t || i === t.alternation && -1 === e.locator[i].toString().indexOf(t.locator[i]); 27752 if (!a && i > t.alternation) for (var n = t.alternation; n < i; n++) if (e.locator[n] !== t.locator[n]) { 27753 i = n, a = !0; 27754 break; 27755 } 27756 if (a) { 27757 e.mloc = e.mloc || {}; 27758 var r = e.locator[i]; 27759 if (void 0 !== r) { 27760 if ("string" == typeof r && (r = r.split(",")[0]), void 0 === e.mloc[r] && (e.mloc[r] = e.locator.slice()), 27761 void 0 !== t) { 27762 for (var o in t.mloc) "string" == typeof o && (o = o.split(",")[0]), void 0 === e.mloc[o] && (e.mloc[o] = t.mloc[o]); 27763 e.locator[i] = Object.keys(e.mloc).join(","); 27764 } 27765 return !0; 27766 } 27767 e.alternation = void 0; 27768 } 27769 return !1; 27770 } 27771 function x(e, t) { 27772 if (e.locator.length !== t.locator.length) return !1; 27773 for (var i = e.alternation + 1; i < e.locator.length; i++) if (e.locator[i] !== t.locator[i]) return !1; 27774 return !0; 27775 } 27776 if (h > e + c._maxTestPos) throw "Inputmask: There is probably an error in your mask definition or in the code. Create an issue on github with an example of the mask you are using. " + s.mask; 27777 if (h === e && void 0 === r.matches) { 27778 if (m.push({ 27779 match: r, 27780 locator: o.reverse(), 27781 cd: k, 27782 mloc: {} 27783 }), !r.optionality || void 0 !== u || !(c.definitions && c.definitions[r.nativeDef] && c.definitions[r.nativeDef].optional || n.default.prototype.definitions[r.nativeDef] && n.default.prototype.definitions[r.nativeDef].optional)) return !0; 27784 g = !0, h = e; 27785 } else if (void 0 !== r.matches) { 27786 if (r.isGroup && u !== r) { 27787 if (r = l(t.matches[t.matches.indexOf(r) + 1], o, u)) return !0; 27788 } else if (r.isOptional) { 27789 var P = r, E = m.length; 27790 if (r = y(r, i, o, u)) { 27791 if (m.forEach((function(e, t) { 27792 t >= E && (e.match.optionality = e.match.optionality ? e.match.optionality + 1 : 1); 27793 })), a = m[m.length - 1].match, void 0 !== u || !p(a, P)) return !0; 27794 g = !0, h = e; 27795 } 27796 } else if (r.isAlternator) { 27797 var S, _ = r, w = [], M = m.slice(), O = o.length, T = !1, C = i.length > 0 ? i.shift() : -1; 27798 if (-1 === C || "string" == typeof C) { 27799 var A, D = h, j = i.slice(), B = []; 27800 if ("string" == typeof C) B = C.split(","); else for (A = 0; A < _.matches.length; A++) B.push(A.toString()); 27801 if (void 0 !== s.excludes[e]) { 27802 for (var R = B.slice(), L = 0, I = s.excludes[e].length; L < I; L++) { 27803 var F = s.excludes[e][L].toString().split(":"); 27804 o.length == F[1] && B.splice(B.indexOf(F[0]), 1); 27805 } 27806 0 === B.length && (delete s.excludes[e], B = R); 27807 } 27808 (!0 === c.keepStatic || isFinite(parseInt(c.keepStatic)) && D >= c.keepStatic) && (B = B.slice(0, 1)); 27809 for (var N = 0; N < B.length; N++) { 27810 A = parseInt(B[N]), m = [], i = "string" == typeof C && v(h, A, O) || j.slice(); 27811 var V = _.matches[A]; 27812 if (V && l(V, [ A ].concat(o), u)) r = !0; else if (0 === N && (T = !0), V && V.matches && V.matches.length > _.matches[0].matches.length) break; 27813 S = m.slice(), h = D, m = []; 27814 for (var G = 0; G < S.length; G++) { 27815 var H = S[G], K = !1; 27816 H.match.jit = H.match.jit || T, H.alternation = H.alternation || O, b(H); 27817 for (var U = 0; U < w.length; U++) { 27818 var $ = w[U]; 27819 if ("string" != typeof C || void 0 !== H.alternation && B.includes(H.locator[H.alternation].toString())) { 27820 if (H.match.nativeDef === $.match.nativeDef) { 27821 K = !0, b($, H); 27822 break; 27823 } 27824 if (f(H, $, c)) { 27825 b(H, $) && (K = !0, w.splice(w.indexOf($), 0, H)); 27826 break; 27827 } 27828 if (f($, H, c)) { 27829 b($, H); 27830 break; 27831 } 27832 if (Z = $, !0 === (Q = H).match.static && !0 !== Z.match.static && Z.match.fn.test(Q.match.def, s, e, !1, c, !1)) { 27833 x(H, $) || void 0 !== d.inputmask.userOptions.keepStatic ? b(H, $) && (K = !0, w.splice(w.indexOf($), 0, H)) : c.keepStatic = !0; 27834 break; 27835 } 27836 } 27837 } 27838 K || w.push(H); 27839 } 27840 } 27841 m = M.concat(w), h = e, g = m.length > 0, r = w.length > 0, i = j.slice(); 27842 } else r = l(_.matches[C] || t.matches[C], [ C ].concat(o), u); 27843 if (r) return !0; 27844 } else if (r.isQuantifier && u !== t.matches[t.matches.indexOf(r) - 1]) for (var q = r, z = i.length > 0 ? i.shift() : 0; z < (isNaN(q.quantifier.max) ? z + 1 : q.quantifier.max) && h <= e; z++) { 27845 var W = t.matches[t.matches.indexOf(q) - 1]; 27846 if (r = l(W, [ z ].concat(o), W)) { 27847 if ((a = m[m.length - 1].match).optionalQuantifier = z >= q.quantifier.min, a.jit = (z + 1) * (W.matches.indexOf(a) + 1) > q.quantifier.jit, 27848 a.optionalQuantifier && p(a, W)) { 27849 g = !0, h = e; 27850 break; 27851 } 27852 return a.jit && (s.jitOffset[e] = W.matches.length - W.matches.indexOf(a)), !0; 27853 } 27854 } else if (r = y(r, i, o, u)) return !0; 27855 } else h++; 27856 var Q, Z; 27857 } 27858 for (var u = i.length > 0 ? i.shift() : 0; u < t.matches.length; u++) if (!0 !== t.matches[u].isQuantifier) { 27859 var p = l(t.matches[u], [ u ].concat(r), o); 27860 if (p && h === e) return p; 27861 if (h > e) break; 27862 } 27863 } 27864 if (e > -1) { 27865 if (void 0 === t) { 27866 for (var b, x = e - 1; void 0 === (b = s.validPositions[x] || s.tests[x]) && x > -1; ) x--; 27867 void 0 !== b && x > -1 && (v = function(e, t) { 27868 var i, a = []; 27869 return Array.isArray(t) || (t = [ t ]), t.length > 0 && (void 0 === t[0].alternation || !0 === c.keepStatic ? 0 === (a = u.call(o, e, t.slice()).locator.slice()).length && (a = t[0].locator.slice()) : t.forEach((function(e) { 27870 "" !== e.def && (0 === a.length ? (i = e.alternation, a = e.locator.slice()) : e.locator[i] && -1 === a[i].toString().indexOf(e.locator[i]) && (a[i] += "," + e.locator[i])); 27871 }))), a; 27872 }(x, b), k = v.join(""), h = x); 27873 } 27874 if (s.tests[e] && s.tests[e][0].cd === k) return s.tests[e]; 27875 for (var P = v.shift(); P < p.length; P++) { 27876 if (y(p[P], v, [ P ]) && h === e || h > e) break; 27877 } 27878 } 27879 return (0 === m.length || g) && m.push({ 27880 match: { 27881 fn: null, 27882 static: !0, 27883 optionality: !1, 27884 casing: null, 27885 def: "", 27886 placeholder: "" 27887 }, 27888 locator: [], 27889 mloc: {}, 27890 cd: k 27891 }), void 0 !== t && s.tests[e] ? r = l.extend(!0, [], m) : (s.tests[e] = l.extend(!0, [], m), 27892 r = s.tests[e]), m.forEach((function(e) { 27893 e.match.optionality = !1; 27894 })), r; 27895 } 27896 }, 27897 7215: function(e, t, i) { 27898 Object.defineProperty(t, "__esModule", { 27899 value: !0 27900 }), t.alternate = s, t.checkAlternationMatch = function(e, t, i) { 27901 for (var a, n = this.opts.greedy ? t : t.slice(0, 1), r = !1, o = void 0 !== i ? i.split(",") : [], l = 0; l < o.length; l++) -1 !== (a = e.indexOf(o[l])) && e.splice(a, 1); 27902 for (var s = 0; s < e.length; s++) if (n.includes(e[s])) { 27903 r = !0; 27904 break; 27905 } 27906 return r; 27907 }, t.handleRemove = function(e, t, i, a, l) { 27908 var u = this, c = this.maskset, f = this.opts; 27909 if ((f.numericInput || u.isRTL) && (t === r.default.BACKSPACE ? t = r.default.DELETE : t === r.default.DELETE && (t = r.default.BACKSPACE), 27910 u.isRTL)) { 27911 var d = i.end; 27912 i.end = i.begin, i.begin = d; 27913 } 27914 var p, h = o.getLastValidPosition.call(u, void 0, !0); 27915 i.end >= o.getBuffer.call(u).length && h >= i.end && (i.end = h + 1); 27916 t === r.default.BACKSPACE ? i.end - i.begin < 1 && (i.begin = o.seekPrevious.call(u, i.begin)) : t === r.default.DELETE && i.begin === i.end && (i.end = o.isMask.call(u, i.end, !0, !0) ? i.end + 1 : o.seekNext.call(u, i.end) + 1); 27917 if (!1 !== (p = m.call(u, i))) { 27918 if (!0 !== a && !1 !== f.keepStatic || null !== f.regex && -1 !== n.getTest.call(u, i.begin).match.def.indexOf("|")) { 27919 var v = s.call(u, !0); 27920 if (v) { 27921 var g = void 0 !== v.caret ? v.caret : v.pos ? o.seekNext.call(u, v.pos.begin ? v.pos.begin : v.pos) : o.getLastValidPosition.call(u, -1, !0); 27922 (t !== r.default.DELETE || i.begin > g) && i.begin; 27923 } 27924 } 27925 !0 !== a && (c.p = t === r.default.DELETE ? i.begin + p : i.begin, c.p = o.determineNewCaretPosition.call(u, { 27926 begin: c.p, 27927 end: c.p 27928 }, !1, !1 === f.insertMode && t === r.default.BACKSPACE ? "none" : void 0).begin); 27929 } 27930 }, t.isComplete = c, t.isSelection = f, t.isValid = d, t.refreshFromBuffer = h, 27931 t.revalidateMask = m; 27932 var a, n = i(4713), r = (a = i(5581)) && a.__esModule ? a : { 27933 default: a 27934 }, o = i(8711), l = i(6030); 27935 function s(e, t, i, a, r, l) { 27936 var u, c, f, p, h, v, m, g, k, y, b, x = this, P = this.dependencyLib, E = this.opts, S = x.maskset, _ = P.extend(!0, {}, S.validPositions), w = P.extend(!0, {}, S.tests), M = !1, O = !1, T = void 0 !== r ? r : o.getLastValidPosition.call(x); 27937 if (l && (y = l.begin, b = l.end, l.begin > l.end && (y = l.end, b = l.begin)), 27938 -1 === T && void 0 === r) u = 0, c = (p = n.getTest.call(x, u)).alternation; else for (;T >= 0; T--) if ((f = S.validPositions[T]) && void 0 !== f.alternation) { 27939 if (p && p.locator[f.alternation] !== f.locator[f.alternation]) break; 27940 u = T, c = S.validPositions[u].alternation, p = f; 27941 } 27942 if (void 0 !== c) { 27943 m = parseInt(u), S.excludes[m] = S.excludes[m] || [], !0 !== e && S.excludes[m].push((0, 27944 n.getDecisionTaker)(p) + ":" + p.alternation); 27945 var C = [], A = -1; 27946 for (h = m; h < o.getLastValidPosition.call(x, void 0, !0) + 1; h++) -1 === A && e <= h && void 0 !== t && (C.push(t), 27947 A = C.length - 1), (v = S.validPositions[h]) && !0 !== v.generatedInput && (void 0 === l || h < y || h >= b) && C.push(v.input), 27948 delete S.validPositions[h]; 27949 for (-1 === A && void 0 !== t && (C.push(t), A = C.length - 1); void 0 !== S.excludes[m] && S.excludes[m].length < 10; ) { 27950 for (S.tests = {}, o.resetMaskSet.call(x, !0), M = !0, h = 0; h < C.length && (g = M.caret || o.getLastValidPosition.call(x, void 0, !0) + 1, 27951 k = C[h], M = d.call(x, g, k, !1, a, !0)); h++) h === A && (O = M), 1 == e && M && (O = { 27952 caretPos: h 27953 }); 27954 if (M) break; 27955 if (o.resetMaskSet.call(x), p = n.getTest.call(x, m), S.validPositions = P.extend(!0, {}, _), 27956 S.tests = P.extend(!0, {}, w), !S.excludes[m]) { 27957 O = s.call(x, e, t, i, a, m - 1, l); 27958 break; 27959 } 27960 var D = (0, n.getDecisionTaker)(p); 27961 if (-1 !== S.excludes[m].indexOf(D + ":" + p.alternation)) { 27962 O = s.call(x, e, t, i, a, m - 1, l); 27963 break; 27964 } 27965 for (S.excludes[m].push(D + ":" + p.alternation), h = m; h < o.getLastValidPosition.call(x, void 0, !0) + 1; h++) delete S.validPositions[h]; 27966 } 27967 } 27968 return O && !1 === E.keepStatic || delete S.excludes[m], O; 27969 } 27970 function u(e, t, i) { 27971 var a = this.opts, n = this.maskset; 27972 switch (a.casing || t.casing) { 27973 case "upper": 27974 e = e.toUpperCase(); 27975 break; 27976 27977 case "lower": 27978 e = e.toLowerCase(); 27979 break; 27980 27981 case "title": 27982 var o = n.validPositions[i - 1]; 27983 e = 0 === i || o && o.input === String.fromCharCode(r.default.SPACE) ? e.toUpperCase() : e.toLowerCase(); 27984 break; 27985 27986 default: 27987 if ("function" == typeof a.casing) { 27988 var l = Array.prototype.slice.call(arguments); 27989 l.push(n.validPositions), e = a.casing.apply(this, l); 27990 } 27991 } 27992 return e; 27993 } 27994 function c(e) { 27995 var t = this, i = this.opts, a = this.maskset; 27996 if ("function" == typeof i.isComplete) return i.isComplete(e, i); 27997 if ("*" !== i.repeat) { 27998 var r = !1, l = o.determineLastRequiredPosition.call(t, !0), s = o.seekPrevious.call(t, l.l); 27999 if (void 0 === l.def || l.def.newBlockMarker || l.def.optionality || l.def.optionalQuantifier) { 28000 r = !0; 28001 for (var u = 0; u <= s; u++) { 28002 var c = n.getTestTemplate.call(t, u).match; 28003 if (!0 !== c.static && void 0 === a.validPositions[u] && !0 !== c.optionality && !0 !== c.optionalQuantifier || !0 === c.static && e[u] !== n.getPlaceholder.call(t, u, c)) { 28004 r = !1; 28005 break; 28006 } 28007 } 28008 } 28009 return r; 28010 } 28011 } 28012 function f(e) { 28013 var t = this.opts.insertMode ? 0 : 1; 28014 return this.isRTL ? e.begin - e.end > t : e.end - e.begin > t; 28015 } 28016 function d(e, t, i, a, r, l, p) { 28017 var g = this, k = this.dependencyLib, y = this.opts, b = g.maskset; 28018 i = !0 === i; 28019 var x = e; 28020 function P(e) { 28021 if (void 0 !== e) { 28022 if (void 0 !== e.remove && (Array.isArray(e.remove) || (e.remove = [ e.remove ]), 28023 e.remove.sort((function(e, t) { 28024 return t.pos - e.pos; 28025 })).forEach((function(e) { 28026 m.call(g, { 28027 begin: e, 28028 end: e + 1 28029 }); 28030 })), e.remove = void 0), void 0 !== e.insert && (Array.isArray(e.insert) || (e.insert = [ e.insert ]), 28031 e.insert.sort((function(e, t) { 28032 return e.pos - t.pos; 28033 })).forEach((function(e) { 28034 "" !== e.c && d.call(g, e.pos, e.c, void 0 === e.strict || e.strict, void 0 !== e.fromIsValid ? e.fromIsValid : a); 28035 })), e.insert = void 0), e.refreshFromBuffer && e.buffer) { 28036 var t = e.refreshFromBuffer; 28037 h.call(g, !0 === t ? t : t.start, t.end, e.buffer), e.refreshFromBuffer = void 0; 28038 } 28039 void 0 !== e.rewritePosition && (x = e.rewritePosition, e = !0); 28040 } 28041 return e; 28042 } 28043 function E(t, i, r) { 28044 var l = !1; 28045 return n.getTests.call(g, t).every((function(s, c) { 28046 var d = s.match; 28047 if (o.getBuffer.call(g, !0), !1 !== (l = (!d.jit || void 0 !== b.validPositions[o.seekPrevious.call(g, t)]) && (null != d.fn ? d.fn.test(i, b, t, r, y, f.call(g, e)) : (i === d.def || i === y.skipOptionalPartCharacter) && "" !== d.def && { 28048 c: n.getPlaceholder.call(g, t, d, !0) || d.def, 28049 pos: t 28050 }))) { 28051 var p = void 0 !== l.c ? l.c : i, h = t; 28052 return p = p === y.skipOptionalPartCharacter && !0 === d.static ? n.getPlaceholder.call(g, t, d, !0) || d.def : p, 28053 !0 !== (l = P(l)) && void 0 !== l.pos && l.pos !== t && (h = l.pos), !0 !== l && void 0 === l.pos && void 0 === l.c ? !1 : (!1 === m.call(g, e, k.extend({}, s, { 28054 input: u.call(g, p, d, h) 28055 }), a, h) && (l = !1), !1); 28056 } 28057 return !0; 28058 })), l; 28059 } 28060 void 0 !== e.begin && (x = g.isRTL ? e.end : e.begin); 28061 var S = !0, _ = k.extend(!0, {}, b.validPositions); 28062 if (!1 === y.keepStatic && void 0 !== b.excludes[x] && !0 !== r && !0 !== a) for (var w = x; w < (g.isRTL ? e.begin : e.end); w++) void 0 !== b.excludes[w] && (b.excludes[w] = void 0, 28063 delete b.tests[w]); 28064 if ("function" == typeof y.preValidation && !0 !== a && !0 !== l && (S = P(S = y.preValidation.call(g, o.getBuffer.call(g), x, t, f.call(g, e), y, b, e, i || r))), 28065 !0 === S) { 28066 if (S = E(x, t, i), (!i || !0 === a) && !1 === S && !0 !== l) { 28067 var M = b.validPositions[x]; 28068 if (!M || !0 !== M.match.static || M.match.def !== t && t !== y.skipOptionalPartCharacter) { 28069 if (y.insertMode || void 0 === b.validPositions[o.seekNext.call(g, x)] || e.end > x) { 28070 var O = !1; 28071 if (b.jitOffset[x] && void 0 === b.validPositions[o.seekNext.call(g, x)] && !1 !== (S = d.call(g, x + b.jitOffset[x], t, !0, !0)) && (!0 !== r && (S.caret = x), 28072 O = !0), e.end > x && (b.validPositions[x] = void 0), !O && !o.isMask.call(g, x, y.keepStatic && 0 === x)) for (var T = x + 1, C = o.seekNext.call(g, x, !1, 0 !== x); T <= C; T++) if (!1 !== (S = E(T, t, i))) { 28073 S = v.call(g, x, void 0 !== S.pos ? S.pos : T) || S, x = T; 28074 break; 28075 } 28076 } 28077 } else S = { 28078 caret: o.seekNext.call(g, x) 28079 }; 28080 } 28081 !1 !== S || !y.keepStatic || !c.call(g, o.getBuffer.call(g)) && 0 !== x || i || !0 === r ? f.call(g, e) && b.tests[x] && b.tests[x].length > 1 && y.keepStatic && !i && !0 !== r && (S = s.call(g, !0)) : S = s.call(g, x, t, i, a, void 0, e), 28082 !0 === S && (S = { 28083 pos: x 28084 }); 28085 } 28086 if ("function" == typeof y.postValidation && !0 !== a && !0 !== l) { 28087 var A = y.postValidation.call(g, o.getBuffer.call(g, !0), void 0 !== e.begin ? g.isRTL ? e.end : e.begin : e, t, S, y, b, i, p); 28088 void 0 !== A && (S = !0 === A ? S : A); 28089 } 28090 S && void 0 === S.pos && (S.pos = x), !1 === S || !0 === l ? (o.resetMaskSet.call(g, !0), 28091 b.validPositions = k.extend(!0, {}, _)) : v.call(g, void 0, x, !0); 28092 var D = P(S); 28093 void 0 !== g.maxLength && (o.getBuffer.call(g).length > g.maxLength && !a && (o.resetMaskSet.call(g, !0), 28094 b.validPositions = k.extend(!0, {}, _), D = !1)); 28095 return D; 28096 } 28097 function p(e, t, i) { 28098 for (var a = this.maskset, r = !1, o = n.getTests.call(this, e), l = 0; l < o.length; l++) { 28099 if (o[l].match && (o[l].match.nativeDef === t.match[i.shiftPositions ? "def" : "nativeDef"] && (!i.shiftPositions || !t.match.static) || o[l].match.nativeDef === t.match.nativeDef || i.regex && !o[l].match.static && o[l].match.fn.test(t.input))) { 28100 r = !0; 28101 break; 28102 } 28103 if (o[l].match && o[l].match.def === t.match.nativeDef) { 28104 r = void 0; 28105 break; 28106 } 28107 } 28108 return !1 === r && void 0 !== a.jitOffset[e] && (r = p.call(this, e + a.jitOffset[e], t, i)), 28109 r; 28110 } 28111 function h(e, t, i) { 28112 var a, n, r = this, s = this.maskset, u = this.opts, c = this.dependencyLib, f = u.skipOptionalPartCharacter, d = r.isRTL ? i.slice().reverse() : i; 28113 if (u.skipOptionalPartCharacter = "", !0 === e) o.resetMaskSet.call(r), s.tests = {}, 28114 e = 0, t = i.length, n = o.determineNewCaretPosition.call(r, { 28115 begin: 0, 28116 end: 0 28117 }, !1).begin; else { 28118 for (a = e; a < t; a++) delete s.validPositions[a]; 28119 n = e; 28120 } 28121 var p = new c.Event("keypress"); 28122 for (a = e; a < t; a++) { 28123 p.keyCode = d[a].toString().charCodeAt(0), r.ignorable = !1; 28124 var h = l.EventHandlers.keypressEvent.call(r, p, !0, !1, !1, n); 28125 !1 !== h && void 0 !== h && (n = h.forwardPosition); 28126 } 28127 u.skipOptionalPartCharacter = f; 28128 } 28129 function v(e, t, i) { 28130 var a = this, r = this.maskset, l = this.dependencyLib; 28131 if (void 0 === e) for (e = t - 1; e > 0 && !r.validPositions[e]; e--) ; 28132 for (var s = e; s < t; s++) { 28133 if (void 0 === r.validPositions[s] && !o.isMask.call(a, s, !1)) if (0 == s ? n.getTest.call(a, s) : r.validPositions[s - 1]) { 28134 var u = n.getTests.call(a, s).slice(); 28135 "" === u[u.length - 1].match.def && u.pop(); 28136 var c, f = n.determineTestTemplate.call(a, s, u); 28137 if (f && (!0 !== f.match.jit || "master" === f.match.newBlockMarker && (c = r.validPositions[s + 1]) && !0 === c.match.optionalQuantifier) && ((f = l.extend({}, f, { 28138 input: n.getPlaceholder.call(a, s, f.match, !0) || f.match.def 28139 })).generatedInput = !0, m.call(a, s, f, !0), !0 !== i)) { 28140 var p = r.validPositions[t].input; 28141 return r.validPositions[t] = void 0, d.call(a, t, p, !0, !0); 28142 } 28143 } 28144 } 28145 } 28146 function m(e, t, i, a) { 28147 var r = this, l = this.maskset, s = this.opts, u = this.dependencyLib; 28148 function c(e, t, i) { 28149 var a = t[e]; 28150 if (void 0 !== a && !0 === a.match.static && !0 !== a.match.optionality && (void 0 === t[0] || void 0 === t[0].alternation)) { 28151 var n = i.begin <= e - 1 ? t[e - 1] && !0 === t[e - 1].match.static && t[e - 1] : t[e - 1], r = i.end > e + 1 ? t[e + 1] && !0 === t[e + 1].match.static && t[e + 1] : t[e + 1]; 28152 return n && r; 28153 } 28154 return !1; 28155 } 28156 var f = 0, h = void 0 !== e.begin ? e.begin : e, v = void 0 !== e.end ? e.end : e, m = !0; 28157 if (e.begin > e.end && (h = e.end, v = e.begin), a = void 0 !== a ? a : h, h !== v || s.insertMode && void 0 !== l.validPositions[a] && void 0 === i || void 0 === t || t.match.optionalQuantifier || t.match.optionality) { 28158 var g, k = u.extend(!0, {}, l.validPositions), y = o.getLastValidPosition.call(r, void 0, !0); 28159 for (l.p = h, g = y; g >= h; g--) delete l.validPositions[g], void 0 === t && delete l.tests[g + 1]; 28160 var b, x, P = a, E = P; 28161 for (t && (l.validPositions[a] = u.extend(!0, {}, t), E++, P++), g = t ? v : v - 1; g <= y; g++) { 28162 if (void 0 !== (b = k[g]) && !0 !== b.generatedInput && (g >= v || g >= h && c(g, k, { 28163 begin: h, 28164 end: v 28165 }))) { 28166 for (;"" !== n.getTest.call(r, E).match.def; ) { 28167 if (!1 !== (x = p.call(r, E, b, s)) || "+" === b.match.def) { 28168 "+" === b.match.def && o.getBuffer.call(r, !0); 28169 var S = d.call(r, E, b.input, "+" !== b.match.def, !0); 28170 if (m = !1 !== S, P = (S.pos || E) + 1, !m && x) break; 28171 } else m = !1; 28172 if (m) { 28173 void 0 === t && b.match.static && g === e.begin && f++; 28174 break; 28175 } 28176 if (!m && o.getBuffer.call(r), E > l.maskLength) break; 28177 E++; 28178 } 28179 "" == n.getTest.call(r, E).match.def && (m = !1), E = P; 28180 } 28181 if (!m) break; 28182 } 28183 if (!m) return l.validPositions = u.extend(!0, {}, k), o.resetMaskSet.call(r, !0), 28184 !1; 28185 } else t && n.getTest.call(r, a).match.cd === t.match.cd && (l.validPositions[a] = u.extend(!0, {}, t)); 28186 return o.resetMaskSet.call(r, !0), f; 28187 } 28188 }, 28189 5581: function(e) { 28190 e.exports = JSON.parse('{"BACKSPACE":8,"BACKSPACE_SAFARI":127,"DELETE":46,"DOWN":40,"END":35,"ENTER":13,"ESCAPE":27,"HOME":36,"INSERT":45,"LEFT":37,"PAGE_DOWN":34,"PAGE_UP":33,"RIGHT":39,"SPACE":32,"TAB":9,"UP":38,"X":88,"Z":90,"CONTROL":17,"PAUSE/BREAK":19,"WINDOWS_LEFT":91,"WINDOWS_RIGHT":92,"KEY_229":229}'); 28191 } 28192 }, t = {}; 28193 function i(a) { 28194 var n = t[a]; 28195 if (void 0 !== n) return n.exports; 28196 var r = t[a] = { 28197 exports: {} 28198 }; 28199 return e[a](r, r.exports, i), r.exports; 28200 } 28201 var a = {}; 28202 return function() { 28203 var e, t = a; 28204 Object.defineProperty(t, "__esModule", { 28205 value: !0 28206 }), t.default = void 0, i(3851), i(219), i(207), i(5296); 28207 var n = ((e = i(2394)) && e.__esModule ? e : { 28208 default: e 28209 }).default; 28210 t.default = n; 28211 }(), a; 28212 }(); 28213})); 28214 28215/***/ }), 28216
vendor: 4,516 bytes, lines 28217-28393
28217/***/ "./node_modules/js-cookie/src/js.cookie.js": 28218/*!*************************************************!*\ 28219 !*** ./node_modules/js-cookie/src/js.cookie.js ***! 28220 \*************************************************/ 28221/***/ (function(module, exports, __webpack_require__) { 28222 28223var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 28224 * JavaScript Cookie v2.2.1 28225 * https://github.com/js-cookie/js-cookie 28226 * 28227 * Copyright 2006, 2015 Klaus Hartl & Fagner Brack 28228 * Released under the MIT license 28229 */ 28230;(function (factory) { 28231 var registeredInModuleLoader; 28232 if (true) { 28233 !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 28234 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 28235 (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : 28236 __WEBPACK_AMD_DEFINE_FACTORY__), 28237 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 28238 registeredInModuleLoader = true; 28239 } 28240 if (true) { 28241 module.exports = factory(); 28242 registeredInModuleLoader = true; 28243 } 28244 if (!registeredInModuleLoader) { 28245 var OldCookies = window.Cookies; 28246 var api = window.Cookies = factory(); 28247 api.noConflict = function () { 28248 window.Cookies = OldCookies; 28249 return api; 28250 }; 28251 } 28252}(function () { 28253 function extend () { 28254 var i = 0; 28255 var result = {}; 28256 for (; i < arguments.length; i++) { 28257 var attributes = arguments[ i ]; 28258 for (var key in attributes) { 28259 result[key] = attributes[key]; 28260 } 28261 } 28262 return result; 28263 } 28264 28265 function decode (s) { 28266 return s.replace(/(%[0-9A-Z]{2})+/g, decodeURIComponent); 28267 } 28268 28269 function init (converter) { 28270 function api() {} 28271 28272 function set (key, value, attributes) { 28273 if (typeof document === 'undefined') { 28274 return; 28275 } 28276 28277 attributes = extend({ 28278 path: '/' 28279 }, api.defaults, attributes); 28280 28281 if (typeof attributes.expires === 'number') { 28282 attributes.expires = new Date(new Date() * 1 + attributes.expires * 864e+5); 28283 } 28284 28285 // We're using "expires" because "max-age" is not supported by IE 28286 attributes.expires = attributes.expires ? attributes.expires.toUTCString() : ''; 28287 28288 try { 28289 var result = JSON.stringify(value); 28290 if (/^[\{\[]/.test(result)) { 28291 value = result; 28292 } 28293 } catch (e) {} 28294 28295 value = converter.write ? 28296 converter.write(value, key) : 28297 encodeURIComponent(String(value)) 28298 .replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent); 28299 28300 key = encodeURIComponent(String(key)) 28301 .replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent) 28302 .replace(/[\(\)]/g, escape); 28303 28304 var stringifiedAttributes = ''; 28305 for (var attributeName in attributes) { 28306 if (!attributes[attributeName]) { 28307 continue; 28308 } 28309 stringifiedAttributes += '; ' + attributeName; 28310 if (attributes[attributeName] === true) { 28311 continue; 28312 } 28313 28314 // Considers RFC 6265 section 5.2: 28315 // ... 28316 // 3. If the remaining unparsed-attributes contains a %x3B (";") 28317 // character: 28318 // Consume the characters of the unparsed-attributes up to, 28319 // not including, the first %x3B (";") character. 28320 // ... 28321 stringifiedAttributes += '=' + attributes[attributeName].split(';')[0]; 28322 } 28323 28324 return (document.cookie = key + '=' + value + stringifiedAttributes); 28325 } 28326 28327 function get (key, json) { 28328 if (typeof document === 'undefined') { 28329 return; 28330 } 28331 28332 var jar = {}; 28333 // To prevent the for loop in the first place assign an empty array 28334 // in case there are no cookies at all. 28335 var cookies = document.cookie ? document.cookie.split('; ') : []; 28336 var i = 0; 28337 28338 for (; i < cookies.length; i++) { 28339 var parts = cookies[i].split('='); 28340 var cookie = parts.slice(1).join('='); 28341 28342 if (!json && cookie.charAt(0) === '"') { 28343 cookie = cookie.slice(1, -1); 28344 } 28345 28346 try { 28347 var name = decode(parts[0]); 28348 cookie = (converter.read || converter)(cookie, name) || 28349 decode(cookie); 28350 28351 if (json) { 28352 try { 28353 cookie = JSON.parse(cookie); 28354 } catch (e) {} 28355 } 28356 28357 jar[name] = cookie; 28358 28359 if (key === name) { 28360 break; 28361 } 28362 } catch (e) {} 28363 } 28364 28365 return key ? jar[key] : jar; 28366 } 28367 28368 api.set = set; 28369 api.get = function (key) { 28370 return get(key, false /* read as raw */); 28371 }; 28372 api.getJSON = function (key) { 28373 return get(key, true /* read as json */); 28374 }; 28375 api.remove = function (key, attributes) { 28376 set(key, '', extend(attributes, { 28377 expires: -1 28378 })); 28379 }; 28380 28381 api.defaults = {}; 28382 28383 api.withConverter = init; 28384 28385 return api; 28386 } 28387 28388 return init(function () {}); 28389})); 28390 28391 28392/***/ }), 28393
vendor: 9,970 bytes, lines 28394-28614
28394/***/ "./node_modules/process/browser.js": 28395/*!*****************************************!*\ 28396 !*** ./node_modules/process/browser.js ***! 28397 \*****************************************/ 28398/***/ (function(module) { 28399 28400// shim for using process in browser 28401var process = module.exports = {}; 28402 28403// cached from whatever global is present so that test runners that stub it 28404// don't break things. But we need to wrap it in a try catch in case it is 28405// wrapped in strict mode code which doesn't define any globals. It's inside a 28406// function because try/catches deoptimize in certain engines. 28407 28408var cachedSetTimeout; 28409var cachedClearTimeout; 28410 28411function defaultSetTimout() { 28412 throw new Error('setTimeout has not been defined'); 28413} 28414function defaultClearTimeout () { 28415 throw new Error('clearTimeout has not been defined'); 28416} 28417(function () { 28418 try { 28419 if (typeof setTimeout === 'function') { 28420 cachedSetTimeout = setTimeout; 28421 } else { 28422 cachedSetTimeout = defaultSetTimout; 28423 } 28424 } catch (e) { 28425 cachedSetTimeout = defaultSetTimout; 28426 } 28427 try { 28428 if (typeof clearTimeout === 'function') { 28429 cachedClearTimeout = clearTimeout; 28430 } else { 28431 cachedClearTimeout = defaultClearTimeout; 28432 } 28433 } catch (e) { 28434 cachedClearTimeout = defaultClearTimeout; 28435 } 28436} ()) 28437function runTimeout(fun) { 28438 if (cachedSetTimeout === setTimeout) { 28439 //normal enviroments in sane situations 28440 return setTimeout(fun, 0); 28441 } 28442 // if setTimeout wasn't available but was latter defined 28443 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { 28444 cachedSetTimeout = setTimeout; 28445 return setTimeout(fun, 0); 28446 } 28447 try { 28448 // when when somebody has screwed with setTimeout but no I.E. maddness 28449 return cachedSetTimeout(fun, 0); 28450 } catch(e){ 28451 try { 28452 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 28453 return cachedSetTimeout.call(null, fun, 0); 28454 } catch(e){ 28455 // 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 28456 return cachedSetTimeout.call(this, fun, 0); 28457 } 28458 } 28459 28460 28461} 28462function runClearTimeout(marker) { 28463 if (cachedClearTimeout === clearTimeout) { 28464 //normal enviroments in sane situations 28465 return clearTimeout(marker); 28466 } 28467 // if clearTimeout wasn't available but was latter defined 28468 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { 28469 cachedClearTimeout = clearTimeout; 28470 return clearTimeout(marker); 28471 } 28472 try { 28473 // when when somebody has screwed with setTimeout but no I.E. maddness 28474 return cachedClearTimeout(marker); 28475 } catch (e){ 28476 try { 28477 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 28478 return cachedClearTimeout.call(null, marker); 28479 } catch (e){ 28480 // 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. 28481 // Some versions of I.E. have different rules for clearTimeout vs setTimeout 28482 return cachedClearTimeout.call(this, marker); 28483 } 28484 } 28485 28486 28487 28488} 28489var queue = []; 28490var draining = false; 28491var currentQueue; 28492var queueIndex = -1; 28493 28494function cleanUpNextTick() { 28495 if (!draining || !currentQueue) { 28496 return; 28497 } 28498 draining = false; 28499 if (currentQueue.length) { 28500 queue = currentQueue.concat(queue); 28501 } else { 28502 queueIndex = -1; 28503 } 28504 if (queue.length) { 28505 drainQueue(); 28506 } 28507} 28508 28509function drainQueue() { 28510 if (draining) { 28511 return; 28512 } 28513 var timeout = runTimeout(cleanUpNextTick); 28514 draining = true; 28515 28516 var len = queue.length; 28517 while(len) { 28518 currentQueue = queue; 28519 queue = []; 28520 while (++queueIndex < len) { 28521 if (currentQueue) { 28522 currentQueue[queueIndex].run(); 28523 } 28524 } 28525 queueIndex = -1; 28526 len = queue.length; 28527 } 28528 currentQueue = null; 28529 draining = false; 28530 runClearTimeout(timeout); 28531} 28532 28533process.nextTick = function (fun) { 28534 var args = new Array(arguments.length - 1); 28535 if (arguments.length > 1) { 28536 for (var i = 1; i < arguments.length; i++) { 28537 args[i - 1] = arguments[i]; 28538 } 28539 } 28540 queue.push(new Item(fun, args)); 28541 if (queue.length === 1 && !draining) { 28542 runTimeout(drainQueue); 28543 } 28544}; 28545 28546// v8 likes predictible objects 28547function Item(fun, array) { 28548 this.fun = fun; 28549 this.array = array; 28550} 28551Item.prototype.run = function () { 28552 this.fun.apply(null, this.array); 28553}; 28554process.title = 'browser'; 28555process.browser = true; 28556process.env = {}; 28557process.argv = []; 28558process.version = ''; // empty string to avoid regexp issues 28559process.versions = {}; 28560 28561function noop() {} 28562 28563process.on = noop; 28564process.addListener = noop; 28565process.once = noop; 28566process.off = noop; 28567process.removeListener = noop; 28568process.removeAllListeners = noop; 28569process.emit = noop; 28570process.prependListener = noop; 28571process.prependOnceListener = noop; 28572 28573process.listeners = function (name) { return [] } 28574 28575process.binding = function (name) { 28576 throw new Error('process.binding is not supported'); 28577}; 28578 28579process.cwd = function () { return '/' }; 28580process.chdir = function (dir) { 28581 throw new Error('process.chdir is not supported'); 28582}; 28583process.umask = function() { return 0; }; 28584 28585 28586/***/ }), 28587 28588/***/ "./node_modules/style-loader/dist/cjs.js!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-8.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-8.use[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css": 28589/*!***************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************!*\ 28590 !*** ./node_modules/style-loader/dist/cjs.js!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-8.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-8.use[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css ***! 28591 \***************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************/ 28592/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 28593 28594"use strict"; 28595__webpack_require__.r(__webpack_exports__); 28596/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js"); 28597/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__); 28598/* harmony import */ var _node_modules_css_loader_dist_cjs_js_clonedRuleSet_8_use_1_node_modules_vue_loader_dist_stylePostLoader_js_node_modules_postcss_loader_dist_cjs_js_clonedRuleSet_8_use_2_node_modules_vue_loader_dist_index_js_ruleSet_0_use_0_logonForm_vue_vue_type_style_index_0_id_8fcbc800_scoped_true_lang_css__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !!../../../../node_modules/css-loader/dist/cjs.js??clonedRuleSet-8.use[1]!../../../../node_modules/vue-loader/dist/stylePostLoader.js!../../../../node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-8.use[2]!../../../../node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css */ "./node_modules/css-loader/dist/cjs.js??clonedRuleSet-8.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-8.use[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css"); 28599 28600 28601 28602var options = {}; 28603 28604options.insert = "head"; 28605options.singleton = false; 28606 28607var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_clonedRuleSet_8_use_1_node_modules_vue_loader_dist_stylePostLoader_js_node_modules_postcss_loader_dist_cjs_js_clonedRuleSet_8_use_2_node_modules_vue_loader_dist_index_js_ruleSet_0_use_0_logonForm_vue_vue_type_style_index_0_id_8fcbc800_scoped_true_lang_css__WEBPACK_IMPORTED_MODULE_1__["default"], options); 28608 28609 28610 28611/* harmony default export */ __webpack_exports__["default"] = (_node_modules_css_loader_dist_cjs_js_clonedRuleSet_8_use_1_node_modules_vue_loader_dist_stylePostLoader_js_node_modules_postcss_loader_dist_cjs_js_clonedRuleSet_8_use_2_node_modules_vue_loader_dist_index_js_ruleSet_0_use_0_logonForm_vue_vue_type_style_index_0_id_8fcbc800_scoped_true_lang_css__WEBPACK_IMPORTED_MODULE_1__["default"].locals || {}); 28612 28613/***/ }), 28614
vendor: 7,205 bytes, lines 28615-28893
28615/***/ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js": 28616/*!****************************************************************************!*\ 28617 !*** ./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js ***! 28618 \****************************************************************************/ 28619/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 28620 28621"use strict"; 28622 28623 28624var isOldIE = function isOldIE() { 28625 var memo; 28626 return function memorize() { 28627 if (typeof memo === 'undefined') { 28628 // Test for IE <= 9 as proposed by Browserhacks 28629 // @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805 28630 // Tests for existence of standard globals is to allow style-loader 28631 // to operate correctly into non-standard environments 28632 // @see https://github.com/webpack-contrib/style-loader/issues/177 28633 memo = Boolean(window && document && document.all && !window.atob); 28634 } 28635 28636 return memo; 28637 }; 28638}(); 28639 28640var getTarget = function getTarget() { 28641 var memo = {}; 28642 return function memorize(target) { 28643 if (typeof memo[target] === 'undefined') { 28644 var styleTarget = document.querySelector(target); // Special case to return head of iframe instead of iframe itself 28645 28646 if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) { 28647 try { 28648 // This will throw an exception if access to iframe is blocked 28649 // due to cross-origin restrictions 28650 styleTarget = styleTarget.contentDocument.head; 28651 } catch (e) { 28652 // istanbul ignore next 28653 styleTarget = null; 28654 } 28655 } 28656 28657 memo[target] = styleTarget; 28658 } 28659 28660 return memo[target]; 28661 }; 28662}(); 28663 28664var stylesInDom = []; 28665 28666function getIndexByIdentifier(identifier) { 28667 var result = -1; 28668 28669 for (var i = 0; i < stylesInDom.length; i++) { 28670 if (stylesInDom[i].identifier === identifier) { 28671 result = i; 28672 break; 28673 } 28674 } 28675 28676 return result; 28677} 28678 28679function modulesToDom(list, options) { 28680 var idCountMap = {}; 28681 var identifiers = []; 28682 28683 for (var i = 0; i < list.length; i++) { 28684 var item = list[i]; 28685 var id = options.base ? item[0] + options.base : item[0]; 28686 var count = idCountMap[id] || 0; 28687 var identifier = "".concat(id, " ").concat(count); 28688 idCountMap[id] = count + 1; 28689 var index = getIndexByIdentifier(identifier); 28690 var obj = { 28691 css: item[1], 28692 media: item[2], 28693 sourceMap: item[3] 28694 }; 28695 28696 if (index !== -1) { 28697 stylesInDom[index].references++; 28698 stylesInDom[index].updater(obj); 28699 } else { 28700 stylesInDom.push({ 28701 identifier: identifier, 28702 updater: addStyle(obj, options), 28703 references: 1 28704 }); 28705 } 28706 28707 identifiers.push(identifier); 28708 } 28709 28710 return identifiers; 28711} 28712 28713function insertStyleElement(options) { 28714 var style = document.createElement('style'); 28715 var attributes = options.attributes || {}; 28716 28717 if (typeof attributes.nonce === 'undefined') { 28718 var nonce = true ? __webpack_require__.nc : 0; 28719 28720 if (nonce) { 28721 attributes.nonce = nonce; 28722 } 28723 } 28724 28725 Object.keys(attributes).forEach(function (key) { 28726 style.setAttribute(key, attributes[key]); 28727 }); 28728 28729 if (typeof options.insert === 'function') { 28730 options.insert(style); 28731 } else { 28732 var target = getTarget(options.insert || 'head'); 28733 28734 if (!target) { 28735 throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid."); 28736 } 28737 28738 target.appendChild(style); 28739 } 28740 28741 return style; 28742} 28743 28744function removeStyleElement(style) { 28745 // istanbul ignore if 28746 if (style.parentNode === null) { 28747 return false; 28748 } 28749 28750 style.parentNode.removeChild(style); 28751} 28752/* istanbul ignore next */ 28753 28754 28755var replaceText = function replaceText() { 28756 var textStore = []; 28757 return function replace(index, replacement) { 28758 textStore[index] = replacement; 28759 return textStore.filter(Boolean).join('\n'); 28760 }; 28761}(); 28762 28763function applyToSingletonTag(style, index, remove, obj) { 28764 var css = remove ? '' : obj.media ? "@media ".concat(obj.media, " {").concat(obj.css, "}") : obj.css; // For old IE 28765 28766 /* istanbul ignore if */ 28767 28768 if (style.styleSheet) { 28769 style.styleSheet.cssText = replaceText(index, css); 28770 } else { 28771 var cssNode = document.createTextNode(css); 28772 var childNodes = style.childNodes; 28773 28774 if (childNodes[index]) { 28775 style.removeChild(childNodes[index]); 28776 } 28777 28778 if (childNodes.length) { 28779 style.insertBefore(cssNode, childNodes[index]); 28780 } else { 28781 style.appendChild(cssNode); 28782 } 28783 } 28784} 28785 28786function applyToTag(style, options, obj) { 28787 var css = obj.css; 28788 var media = obj.media; 28789 var sourceMap = obj.sourceMap; 28790 28791 if (media) { 28792 style.setAttribute('media', media); 28793 } else { 28794 style.removeAttribute('media'); 28795 } 28796 28797 if (sourceMap && typeof btoa !== 'undefined') { 28798 css += "\n/*# sourceMappingURL=data:application/json;base64,".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), " */"); 28799 } // For old IE 28800 28801 /* istanbul ignore if */ 28802 28803 28804 if (style.styleSheet) { 28805 style.styleSheet.cssText = css; 28806 } else { 28807 while (style.firstChild) { 28808 style.removeChild(style.firstChild); 28809 } 28810 28811 style.appendChild(document.createTextNode(css)); 28812 } 28813} 28814 28815var singleton = null; 28816var singletonCounter = 0; 28817 28818function addStyle(obj, options) { 28819 var style; 28820 var update; 28821 var remove; 28822 28823 if (options.singleton) { 28824 var styleIndex = singletonCounter++; 28825 style = singleton || (singleton = insertStyleElement(options)); 28826 update = applyToSingletonTag.bind(null, style, styleIndex, false); 28827 remove = applyToSingletonTag.bind(null, style, styleIndex, true); 28828 } else { 28829 style = insertStyleElement(options); 28830 update = applyToTag.bind(null, style, options); 28831 28832 remove = function remove() { 28833 removeStyleElement(style); 28834 }; 28835 } 28836 28837 update(obj); 28838 return function updateStyle(newObj) { 28839 if (newObj) { 28840 if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap) { 28841 return; 28842 } 28843 28844 update(obj = newObj); 28845 } else { 28846 remove(); 28847 } 28848 }; 28849} 28850 28851module.exports = function (list, options) { 28852 options = options || {}; // Force single-tag solution on IE6-9, which has a hard limit on the # of <style> 28853 // tags it will allow on a page 28854 28855 if (!options.singleton && typeof options.singleton !== 'boolean') { 28856 options.singleton = isOldIE(); 28857 } 28858 28859 list = list || []; 28860 var lastIdentifiers = modulesToDom(list, options); 28861 return function update(newList) { 28862 newList = newList || []; 28863 28864 if (Object.prototype.toString.call(newList) !== '[object Array]') { 28865 return; 28866 } 28867 28868 for (var i = 0; i < lastIdentifiers.length; i++) { 28869 var identifier = lastIdentifiers[i]; 28870 var index = getIndexByIdentifier(identifier); 28871 stylesInDom[index].references--; 28872 } 28873 28874 var newLastIdentifiers = modulesToDom(newList, options); 28875 28876 for (var _i = 0; _i < lastIdentifiers.length; _i++) { 28877 var _identifier = lastIdentifiers[_i]; 28878 28879 var _index = getIndexByIdentifier(_identifier); 28880 28881 if (stylesInDom[_index].references === 0) { 28882 stylesInDom[_index].updater(); 28883 28884 stylesInDom.splice(_index, 1); 28885 } 28886 } 28887 28888 lastIdentifiers = newLastIdentifiers; 28889 }; 28890}; 28891 28892/***/ }), 28893
vendor: 2,109 bytes, lines 28894-28909
28894/***/ "./node_modules/vue-axios/dist/vue-axios.esm.min.js": 28895/*!**********************************************************!*\ 28896 !*** ./node_modules/vue-axios/dist/vue-axios.esm.min.js ***! 28897 \**********************************************************/ 28898/***/ (function(module, __webpack_exports__, __webpack_require__) { 28899 28900"use strict"; 28901__webpack_require__.r(__webpack_exports__); 28902/* harmony export */ __webpack_require__.d(__webpack_exports__, { 28903/* harmony export */ "default": function() { return /* binding */ plugin; } 28904/* harmony export */ }); 28905/* module decorator */ module = __webpack_require__.hmd(module); 28906function _typeof(e){return _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},_typeof(e)}function plugin(e,n){if(!e.vueAxiosInstalled){var o=isAxiosLike(n)?migrateToMultipleInstances(n):n;if(isValidConfig(o)){var t=getVueVersion(e);if(t){var i=t<3?registerOnVue2:registerOnVue3;Object.keys(o).forEach((function(n){i(e,n,o[n])})),e.vueAxiosInstalled=!0}else console.error("[vue-axios] unknown Vue version")}else console.error("[vue-axios] configuration is invalid, expected options are either <axios_instance> or { <registration_key>: <axios_instance> }")}}function registerOnVue2(e,n,o){Object.defineProperty(e.prototype,n,{get:function(){return o}}),e[n]=o}function registerOnVue3(e,n,o){e.config.globalProperties[n]=o,e[n]=o}function isAxiosLike(e){return e&&"function"==typeof e.get&&"function"==typeof e.post}function migrateToMultipleInstances(e){return{axios:e,$http:e}}function isValidConfig(e){return"object"===_typeof(e)&&Object.keys(e).every((function(n){return isAxiosLike(e[n])}))}function getVueVersion(e){return e&&e.version&&Number(e.version.split(".")[0])}"object"==("undefined"==typeof exports?"undefined":_typeof(exports))?module.exports=plugin:"function"==typeof define&&__webpack_require__.amdO?define([],(function(){return plugin})):window.Vue&&window.axios&&window.Vue.use&&Vue.use(plugin,window.axios); 28907 28908/***/ }), 28909
vendor: 635 bytes, lines 28910-28931
28910/***/ "./node_modules/vue-loader/dist/exportHelper.js": 28911/*!******************************************************!*\ 28912 !*** ./node_modules/vue-loader/dist/exportHelper.js ***! 28913 \******************************************************/ 28914/***/ (function(__unused_webpack_module, exports) { 28915 28916"use strict"; 28917 28918Object.defineProperty(exports, "__esModule", ({ value: true })); 28919// runtime helper for setting properties on components 28920// in a tree-shakable way 28921exports["default"] = (sfc, props) => { 28922 const target = sfc.__vccOpts || sfc; 28923 for (const [key, val] of props) { 28924 target[key] = val; 28925 } 28926 return target; 28927}; 28928 28929 28930/***/ }), 28931
28932/***/ "./resources/assets/js/components/logonForm.vue": 28933/*!******************************************************!*\ 28934 !*** ./resources/assets/js/components/logonForm.vue ***! 28935 \******************************************************/ 28936/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 28937 28938"use strict"; 28939__webpack_require__.r(__webpack_exports__); 28940/* harmony import */ var _logonForm_vue_vue_type_template_id_8fcbc800_scoped_true__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./logonForm.vue?vue&type=template&id=8fcbc800&scoped=true */ "./resources/assets/js/components/logonForm.vue?vue&type=template&id=8fcbc800&scoped=true"); 28941/* harmony import */ var _logonForm_vue_vue_type_script_lang_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./logonForm.vue?vue&type=script&lang=js */ "./resources/assets/js/components/logonForm.vue?vue&type=script&lang=js"); 28942/* harmony import */ var _logonForm_vue_vue_type_style_index_0_id_8fcbc800_scoped_true_lang_css__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css */ "./resources/assets/js/components/logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css"); 28943/* harmony import */ var D_breket_loc_breket_test_loc_node_modules_vue_loader_dist_exportHelper_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./node_modules/vue-loader/dist/exportHelper.js */ "./node_modules/vue-loader/dist/exportHelper.js"); 28944 28945 28946 28947 28948; 28949 28950 28951const __exports__ = /*#__PURE__*/(0,D_breket_loc_breket_test_loc_node_modules_vue_loader_dist_exportHelper_js__WEBPACK_IMPORTED_MODULE_3__["default"])(_logonForm_vue_vue_type_script_lang_js__WEBPACK_IMPORTED_MODULE_1__["default"], [['render',_logonForm_vue_vue_type_template_id_8fcbc800_scoped_true__WEBPACK_IMPORTED_MODULE_0__.render],['__scopeId',"data-v-8fcbc800"],['__file',"resources/assets/js/components/logonForm.vue"]]) 28952/* hot reload */ 28953if (false) {} 28954 28955 28956/* harmony default export */ __webpack_exports__["default"] = (__exports__); 28957 28958/***/ }), 28959 28960/***/ "./resources/assets/js/components/logonForm.vue?vue&type=script&lang=js": 28961/*!******************************************************************************!*\ 28962 !*** ./resources/assets/js/components/logonForm.vue?vue&type=script&lang=js ***! 28963 \******************************************************************************/ 28964/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 28965 28966"use strict"; 28967__webpack_require__.r(__webpack_exports__); 28968/* harmony export */ __webpack_require__.d(__webpack_exports__, { 28969/* harmony export */ "default": function() { return /* reexport safe */ _node_modules_babel_loader_lib_index_js_clonedRuleSet_5_use_0_node_modules_vue_loader_dist_index_js_ruleSet_0_use_0_logonForm_vue_vue_type_script_lang_js__WEBPACK_IMPORTED_MODULE_0__["default"]; } 28970/* harmony export */ }); 28971/* harmony import */ var _node_modules_babel_loader_lib_index_js_clonedRuleSet_5_use_0_node_modules_vue_loader_dist_index_js_ruleSet_0_use_0_logonForm_vue_vue_type_script_lang_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!../../../../node_modules/babel-loader/lib/index.js??clonedRuleSet-5.use[0]!../../../../node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./logonForm.vue?vue&type=script&lang=js */ "./node_modules/babel-loader/lib/index.js??clonedRuleSet-5.use[0]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=script&lang=js"); 28972 28973 28974/***/ }), 28975 28976/***/ "./resources/assets/js/components/logonForm.vue?vue&type=template&id=8fcbc800&scoped=true": 28977/*!************************************************************************************************!*\ 28978 !*** ./resources/assets/js/components/logonForm.vue?vue&type=template&id=8fcbc800&scoped=true ***! 28979 \************************************************************************************************/ 28980/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 28981 28982"use strict"; 28983__webpack_require__.r(__webpack_exports__); 28984/* harmony export */ __webpack_require__.d(__webpack_exports__, { 28985/* harmony export */ "render": function() { return /* reexport safe */ _node_modules_babel_loader_lib_index_js_clonedRuleSet_5_use_0_node_modules_vue_loader_dist_templateLoader_js_ruleSet_1_rules_2_node_modules_vue_loader_dist_index_js_ruleSet_0_use_0_logonForm_vue_vue_type_template_id_8fcbc800_scoped_true__WEBPACK_IMPORTED_MODULE_0__.render; } 28986/* harmony export */ }); 28987/* harmony import */ var _node_modules_babel_loader_lib_index_js_clonedRuleSet_5_use_0_node_modules_vue_loader_dist_templateLoader_js_ruleSet_1_rules_2_node_modules_vue_loader_dist_index_js_ruleSet_0_use_0_logonForm_vue_vue_type_template_id_8fcbc800_scoped_true__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!../../../../node_modules/babel-loader/lib/index.js??clonedRuleSet-5.use[0]!../../../../node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[2]!../../../../node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./logonForm.vue?vue&type=template&id=8fcbc800&scoped=true */ "./node_modules/babel-loader/lib/index.js??clonedRuleSet-5.use[0]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=template&id=8fcbc800&scoped=true"); 28988 28989 28990/***/ }), 28991 28992/***/ "./resources/assets/js/components/logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css": 28993/*!**************************************************************************************************************!*\ 28994 !*** ./resources/assets/js/components/logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css ***! 28995 \**************************************************************************************************************/ 28996/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 28997 28998"use strict"; 28999__webpack_require__.r(__webpack_exports__); 29000/* harmony import */ var _node_modules_style_loader_dist_cjs_js_node_modules_css_loader_dist_cjs_js_clonedRuleSet_8_use_1_node_modules_vue_loader_dist_stylePostLo
29000ader_js_node_modules_postcss_loader_dist_cjs_js_clonedRuleSet_8_use_2_node_modules_vue_loader_dist_index_js_ruleSet_0_use_0_logonForm_vue_vue_type_style_index_0_id_8fcbc800_scoped_true_lang_css__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!../../../../node_modules/style-loader/dist/cjs.js!../../../../node_modules/css-loader/dist/cjs.js??clonedRuleSet-8.use[1]!../../../../node_modules/vue-loader/dist/stylePostLoader.js!../../../../node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-8.use[2]!../../../../node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css */ "./node_modules/style-loader/dist/cjs.js!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-8.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-8.use[2]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./resources/assets/js/components/logonForm.vue?vue&type=style&index=0&id=8fcbc800&scoped=true&lang=css"); 29001 29002 29003/***/ }), 29004
vendor: 24,475 bytes, lines 29005-29238
29005/***/ "./node_modules/vue/dist/vue.esm-bundler.js": 29006/*!**************************************************!*\ 29007 !*** ./node_modules/vue/dist/vue.esm-bundler.js ***! 29008 \**************************************************/ 29009/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 29010 29011"use strict"; 29012__webpack_require__.r(__webpack_exports__); 29013/* harmony export */ __webpack_require__.d(__webpack_exports__, { 29014/* harmony export */ "BaseTransition": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.BaseTransition; }, 29015/* harmony export */ "Comment": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Comment; }, 29016/* harmony export */ "EffectScope": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.EffectScope; }, 29017/* harmony export */ "Fragment": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Fragment; }, 29018/* harmony export */ "KeepAlive": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.KeepAlive; }, 29019/* harmony export */ "ReactiveEffect": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect; }, 29020/* harmony export */ "Static": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Static; }, 29021/* harmony export */ "Suspense": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Suspense; }, 29022/* harmony export */ "Teleport": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Teleport; }, 29023/* harmony export */ "Text": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Text; }, 29024/* harmony export */ "Transition": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Transition; }, 29025/* harmony export */ "TransitionGroup": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.TransitionGroup; }, 29026/* harmony export */ "VueElement": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.VueElement; }, 29027/* harmony export */ "callWithAsyncErrorHandling": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling; }, 29028/* harmony export */ "callWithErrorHandling": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.callWithErrorHandling; }, 29029/* harmony export */ "camelize": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.camelize; }, 29030/* harmony export */ "capitalize": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.capitalize; }, 29031/* harmony export */ "cloneVNode": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.cloneVNode; }, 29032/* harmony export */ "compatUtils": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.compatUtils; }, 29033/* harmony export */ "compile": function() { return /* binding */ compileToFunction; }, 29034/* harmony export */ "computed": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.computed; }, 29035/* harmony export */ "createApp": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createApp; }, 29036/* harmony export */ "createBlock": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createBlock; }, 29037/* harmony export */ "createCommentVNode": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode; }, 29038/* harmony export */ "createElementBlock": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createElementBlock; }, 29039/* harmony export */ "createElementVNode": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createElementVNode; }, 29040/* harmony export */ "createHydrationRenderer": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer; }, 29041/* harmony export */ "createPropsRestProxy": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createPropsRestProxy; }, 29042/* harmony export */ "createRenderer": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createRenderer; }, 29043/* harmony export */ "createSSRApp": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createSSRApp; }, 29044/* harmony export */ "createSlots": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createSlots; }, 29045/* harmony export */ "createStaticVNode": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode; }, 29046/* harmony export */ "createTextVNode": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createTextVNode; }, 29047/* harmony export */ "createVNode": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createVNode; }, 29048/* harmony export */ "customRef": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.customRef; }, 29049/* harmony export */ "defineAsyncComponent": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineAsyncComponent; }, 29050/* harmony export */ "defineComponent": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineComponent; }, 29051/* harmony export */ "defineCustomElement": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineCustomElement; }, 29052/* harmony export */ "defineEmits": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineEmits; }, 29053/* harmony export */ "defineExpose": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineExpose; }, 29054/* harmony export */ "defineProps": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineProps; }, 29055/* harmony export */ "defineSSRCustomElement": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineSSRCustomElement; }, 29056/* harmony export */ "devtools": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.devtools; }, 29057/* harmony export */ "effect": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.effect; }, 29058/* harmony export */ "effectScope": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.effectScope; }, 29059/* harmony export */ "getCurrentInstance": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance; }, 29060/* harmony export */ "getCurrentScope": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope; }, 29061/* harmony export */ "getTransitionRawChildren": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren; }, 29062/* harmony export */ "guardReactiveProps": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.guardReactiveProps; }, 29063/* harmony export */ "h": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.h; }, 29064/* harmony export */ "handleError": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.handleError; }, 29065/* harmony export */ "hydrate": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.hydrate; }, 29066/* harmony export */ "initCustomFormatter": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.initCustomFormatter; }, 29067/* harmony export */ "initDirectivesForSSR": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.initDirectivesForSSR; }, 29068/* harmony export */ "inject": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.inject; }, 29069/* harmony export */ "isMemoSame": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isMemoSame; }, 29070/* harmony export */ "isProxy": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isProxy; }, 29071/* harmony export */ "isReactive": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isReactive; }, 29072/* harmony export */ "isReadonly": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isReadonly; }, 29073/* harmony export */ "isRef": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isRef; }, 29074/* harmony export */ "isRuntimeOnly": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly; }, 29075/* harmony export */ "isShallow": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isShallow; }, 29076/* harmony export */ "isVNode": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isVNode; }, 29077/* harmony export */ "markRaw": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.markRaw; }, 29078/* harmony export */ "mergeDefaults": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.mergeDefaults; }, 29079/* harmony export */ "mergeProps": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.mergeProps; }, 29080/* harmony export */ "nextTick": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.nextTick; }, 29081/* harmony export */ "normalizeClass": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.normalizeClass; }, 29082/* harmony export */ "normalizeProps": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.normalizeProps; }, 29083/* harmony export */ "normalizeStyle": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle; }, 29084/* harmony export */ "onActivated": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onActivated; }, 29085/* harmony export */ "onBeforeMount": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount; }, 29086/* harmony export */ "onBeforeUnmount": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount; }, 29087/* harmony export */ "onBeforeUpdate": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onBeforeUpdate; }, 29088/* harmony export */ "onDeactivated": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onDeactivated; }, 29089/* harmony export */ "onErrorCaptured": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onErrorCaptured; }, 29090/* harmony export */ "onMounted": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onMounted; }, 29091/* harmony export */ "onRenderTracked": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onRenderTracked; }, 29092/* harmony export */ "onRenderTriggered": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onRenderTriggered; }, 29093/* harmony export */ "onScopeDispose": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose; }, 29094/* harmony export */ "onServerPrefetch": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onServerPrefetch; }, 29095/* harmony export */ "onUnmounted": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onUnmounted; }, 29096/* harmony export */ "onUpdated": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onUpdated; }, 29097/* harmony export */ "openBlock": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.openBlock; }, 29098/* harmony export */ "popScopeId": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.popScopeId; }, 29099/* harmony export */ "provide": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.provide; }, 29100/* harmony export */ "proxyRefs": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.proxyRefs; }, 29101/* harmony export */ "pushScopeId": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.pushScopeId; }, 29102/* harmony export */ "queuePostFlushCb": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.queuePostFlushCb; }, 29103/* harmony export */ "reactive": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.reactive; }, 29104/* harmony export */ "readonly": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.readonly; }, 29105/* harmony export */ "ref": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ref; }, 29106/* harmony export */ "registerRuntimeCompiler": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeCompiler; }, 29107/* harmony export */ "render": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.render; }, 29108/* harmony export */ "renderList": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.renderList; }, 29109/* harmony export */ "renderSlot": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.renderSlot; }, 29110/* harmony export */ "resolveComponent": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveComponent; }, 29111/* harmony export */ "resolveDirective": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveDirective; }, 29112/* harmony export */ "resolveDynamicComponent": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent; }, 29113/* harmony export */ "resolveFilter": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveFilter; }, 29114/* harmony export */ "resolveTransitionHooks": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks; }, 29115/* harmony export */ "setBlockTracking": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.setBlockTracking; }, 29116/* harmony export */ "setDevtoolsHook": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.setDevtoolsHook; }, 29117/* harmony export */ "setTransitionHooks": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks; }, 29118/* harmony export */ "shallowReactive": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.shallowReactive; }, 29119/* harmony export */ "shallowReadonly": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly; }, 29120/* harmony export */ "shallowRef": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.shallowRef; }, 29121/* harmony export */ "ssrContextKey": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ssrContextKey; }, 29122/* harmony export */ "ssrUtils": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ssrUtils; }, 29123/* harmony export */ "stop": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.stop; }, 29124/* harmony export */ "toDisplayString": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toDisplayString; }, 29125/* harmony export */ "toHandlerKey": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey; }, 29126/* harmony export */ "toHandlers": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toHandlers; }, 29127/* harmony export */ "toRaw": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toRaw; }, 29128/* harmony export */ "toRef": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toRef; }, 29129/* harmony export */ "toRefs": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toRefs; }, 29130/* harmony export */ "transformVNodeArgs": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.transformVNodeArgs; }, 29131/* harmony export */ "triggerRef": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.triggerRef; }, 29132/* harmony export */ "unref": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.unref; }, 29133/* harmony export */ "useAttrs": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useAttrs; }, 29134/* harmony export */ "useCssModule": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useCssModule; }, 29135/* harmony export */ "useCssVars": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useCssVars; }, 29136/* harmony export */ "useSSRContext": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useSSRContext; }, 29137/* harmony export */ "useSlots": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useSlots; }, 29138/* harmony export */ "useTransitionState": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useTransitionState; }, 29139/* harmony export */ "vModelCheckbox": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelCheckbox; }, 29140/* harmony export */ "vModelDynamic": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelDynamic; }, 29141/* harmony export */ "vModelRadio": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelRadio; }, 29142/* harmony export */ "vModelSelect": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelSelect; }, 29143/* harmony export */ "vModelText": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelText; }, 29144/* harmony export */ "vShow": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vShow; }, 29145/* harmony export */ "version": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.version; }, 29146/* harmony export */ "warn": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.warn; }, 29147/* harmony export */ "watch": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watch; }, 29148/* harmony export */ "watchEffect": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watchEffect; }, 29149/* harmony export */ "watchPostEffect": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watchPostEffect; }, 29150/* harmony export */ "watchSyncEffect": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watchSyncEffect; }, 29151/* harmony export */ "withAsyncContext": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withAsyncContext; }, 29152/* harmony export */ "withCtx": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withCtx; }, 29153/* harmony export */ "withDefaults": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withDefaults; }, 29154/* harmony export */ "withDirectives": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withDirectives; }, 29155/* harmony export */ "withKeys": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withKeys; }, 29156/* harmony export */ "withMemo": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withMemo; }, 29157/* harmony export */ "withModifiers": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withModifiers; }, 29158/* harmony export */ "withScopeId": function() { return /* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withScopeId; } 29159/* harmony export */ }); 29160/* 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"); 29161/* 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"); 29162/* 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"); 29163/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js"); 29164 29165 29166 29167 29168 29169 29170function initDev() { 29171 { 29172 (0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.initCustomFormatter)(); 29173 } 29174} 29175 29176// This entry is the "full-build" that includes both the runtime 29177if ((true)) { 29178 initDev(); 29179} 29180const compileCache = Object.create(null); 29181function compileToFunction(template, options) { 29182 if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_2__.isString)(template)) { 29183 if (template.nodeType) { 29184 template = template.innerHTML; 29185 } 29186 else { 29187 ( true) && (0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.warn)(`invalid template option: `, template); 29188 return _vue_shared__WEBPACK_IMPORTED_MODULE_2__.NOOP; 29189 } 29190 } 29191 const key = template; 29192 const cached = compileCache[key]; 29193 if (cached) { 29194 return cached; 29195 } 29196 if (template[0] === '#') { 29197 const el = document.querySelector(template); 29198 if (( true) && !el) { 29199 (0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.warn)(`Template element not found or is empty: ${template}`); 29200 } 29201 // __UNSAFE__ 29202 // Reason: potential execution of JS expressions in in-DOM template. 29203 // The user must make sure the in-DOM template is trusted. If it's rendered 29204 // by the server, the template should not contain any user data. 29205 template = el ? el.innerHTML : ``; 29206 } 29207 const opts = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_2__.extend)({ 29208 hoistStatic: true, 29209 onError: ( true) ? onError : 0, 29210 onWarn: ( true) ? e => onError(e, true) : 0 29211 }, options); 29212 if (!opts.isCustomElement && typeof customElements !== 'undefined') { 29213 opts.isCustomElement = tag => !!customElements.get(tag); 29214 } 29215 const { code } = (0,_vue_compiler_dom__WEBPACK_IMPORTED_MODULE_3__.compile)(template, opts); 29216 function onError(err, asWarning = false) { 29217 const message = asWarning 29218 ? err.message 29219 : `Template compilation error: ${err.message}`; 29220 const codeFrame = err.loc && 29221 (0,_vue_shared__WEBPACK_IMPORTED_MODULE_2__.generateCodeFrame)(template, err.loc.start.offset, err.loc.end.offset); 29222 (0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.warn)(codeFrame ? `${message}\n${codeFrame}` : message); 29223 } 29224 // The wildcard import results in a huge object with every export 29225 // with keys that cannot be mangled, and can be quite heavy size-wise. 29226 // In the global build we know `Vue` is available globally so we can avoid 29227 // the wildcard object. 29228 const render = (new Function('Vue', code)(_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__)); 29229 render._rc = true; 29230 return (compileCache[key] = render); 29231} 29232(0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.registerRuntimeCompiler)(compileToFunction); 29233 29234 29235 29236 29237/***/ }), 29238
vendor: 1,409 bytes, lines 29239-29282
29239/***/ "./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js": 29240/*!*********************************************************************!*\ 29241 !*** ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js ***! 29242 \*********************************************************************/ 29243/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 29244 29245"use strict"; 29246__webpack_require__.r(__webpack_exports__); 29247/* harmony export */ __webpack_require__.d(__webpack_exports__, { 29248/* harmony export */ "default": function() { return /* binding */ _asyncToGenerator; } 29249/* harmony export */ }); 29250function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { 29251 try { 29252 var info = gen[key](arg); 29253 var value = info.value; 29254 } catch (error) { 29255 reject(error); 29256 return; 29257 } 29258 if (info.done) { 29259 resolve(value); 29260 } else { 29261 Promise.resolve(value).then(_next, _throw); 29262 } 29263} 29264function _asyncToGenerator(fn) { 29265 return function () { 29266 var self = this, 29267 args = arguments; 29268 return new Promise(function (resolve, reject) { 29269 var gen = fn.apply(self, args); 29270 function _next(value) { 29271 asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); 29272 } 29273 function _throw(err) { 29274 asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); 29275 } 29276 _next(undefined); 29277 }); 29278 }; 29279} 29280 29281/***/ }), 29282
vendor: 14,734 bytes, lines 29283-29611
29283/***/ "./node_modules/@babel/runtime/helpers/esm/regeneratorRuntime.js": 29284/*!***********************************************************************!*\ 29285 !*** ./node_modules/@babel/runtime/helpers/esm/regeneratorRuntime.js ***! 29286 \***********************************************************************/ 29287/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 29288 29289"use strict"; 29290__webpack_require__.r(__webpack_exports__); 29291/* harmony export */ __webpack_require__.d(__webpack_exports__, { 29292/* harmony export */ "default": function() { return /* binding */ _regeneratorRuntime; } 29293/* harmony export */ }); 29294/* harmony import */ var _typeof_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./typeof.js */ "./node_modules/@babel/runtime/helpers/esm/typeof.js"); 29295 29296function _regeneratorRuntime() { 29297 "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ 29298 _regeneratorRuntime = function _regeneratorRuntime() { 29299 return exports; 29300 }; 29301 var exports = {}, 29302 Op = Object.prototype, 29303 hasOwn = Op.hasOwnProperty, 29304 defineProperty = Object.defineProperty || function (obj, key, desc) { 29305 obj[key] = desc.value; 29306 }, 29307 $Symbol = "function" == typeof Symbol ? Symbol : {}, 29308 iteratorSymbol = $Symbol.iterator || "@@iterator", 29309 asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", 29310 toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; 29311 function define(obj, key, value) { 29312 return Object.defineProperty(obj, key, { 29313 value: value, 29314 enumerable: !0, 29315 configurable: !0, 29316 writable: !0 29317 }), obj[key]; 29318 } 29319 try { 29320 define({}, ""); 29321 } catch (err) { 29322 define = function define(obj, key, value) { 29323 return obj[key] = value; 29324 }; 29325 } 29326 function wrap(innerFn, outerFn, self, tryLocsList) { 29327 var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, 29328 generator = Object.create(protoGenerator.prototype), 29329 context = new Context(tryLocsList || []); 29330 return defineProperty(generator, "_invoke", { 29331 value: makeInvokeMethod(innerFn, self, context) 29332 }), generator; 29333 } 29334 function tryCatch(fn, obj, arg) { 29335 try { 29336 return { 29337 type: "normal", 29338 arg: fn.call(obj, arg) 29339 }; 29340 } catch (err) { 29341 return { 29342 type: "throw", 29343 arg: err 29344 }; 29345 } 29346 } 29347 exports.wrap = wrap; 29348 var ContinueSentinel = {}; 29349 function Generator() {} 29350 function GeneratorFunction() {} 29351 function GeneratorFunctionPrototype() {} 29352 var IteratorPrototype = {}; 29353 define(IteratorPrototype, iteratorSymbol, function () { 29354 return this; 29355 }); 29356 var getProto = Object.getPrototypeOf, 29357 NativeIteratorPrototype = getProto && getProto(getProto(values([]))); 29358 NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); 29359 var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); 29360 function defineIteratorMethods(prototype) { 29361 ["next", "throw", "return"].forEach(function (method) { 29362 define(prototype, method, function (arg) { 29363 return this._invoke(method, arg); 29364 }); 29365 }); 29366 } 29367 function AsyncIterator(generator, PromiseImpl) { 29368 function invoke(method, arg, resolve, reject) { 29369 var record = tryCatch(generator[method], generator, arg); 29370 if ("throw" !== record.type) { 29371 var result = record.arg, 29372 value = result.value; 29373 return value && "object" == (0,_typeof_js__WEBPACK_IMPORTED_MODULE_0__["default"])(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { 29374 invoke("next", value, resolve, reject); 29375 }, function (err) { 29376 invoke("throw", err, resolve, reject); 29377 }) : PromiseImpl.resolve(value).then(function (unwrapped) { 29378 result.value = unwrapped, resolve(result); 29379 }, function (error) { 29380 return invoke("throw", error, resolve, reject); 29381 }); 29382 } 29383 reject(record.arg); 29384 } 29385 var previousPromise; 29386 defineProperty(this, "_invoke", { 29387 value: function value(method, arg) { 29388 function callInvokeWithMethodAndArg() { 29389 return new PromiseImpl(function (resolve, reject) { 29390 invoke(method, arg, resolve, reject); 29391 }); 29392 } 29393 return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); 29394 } 29395 }); 29396 } 29397 function makeInvokeMethod(innerFn, self, context) { 29398 var state = "suspendedStart"; 29399 return function (method, arg) { 29400 if ("executing" === state) throw new Error("Generator is already running"); 29401 if ("completed" === state) { 29402 if ("throw" === method) throw arg; 29403 return doneResult(); 29404 } 29405 for (context.method = method, context.arg = arg;;) { 29406 var delegate = context.delegate; 29407 if (delegate) { 29408 var delegateResult = maybeInvokeDelegate(delegate, context); 29409 if (delegateResult) { 29410 if (delegateResult === ContinueSentinel) continue; 29411 return delegateResult; 29412 } 29413 } 29414 if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { 29415 if ("suspendedStart" === state) throw state = "completed", context.arg; 29416 context.dispatchException(context.arg); 29417 } else "return" === context.method && context.abrupt("return", context.arg); 29418 state = "executing"; 29419 var record = tryCatch(innerFn, self, context); 29420 if ("normal" === record.type) { 29421 if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; 29422 return { 29423 value: record.arg, 29424 done: context.done 29425 }; 29426 } 29427 "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); 29428 } 29429 }; 29430 } 29431 function maybeInvokeDelegate(delegate, context) { 29432 var method = delegate.iterator[context.method]; 29433 if (undefined === method) { 29434 if (context.delegate = null, "throw" === context.method) { 29435 if (delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel; 29436 context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method"); 29437 } 29438 return ContinueSentinel; 29439 } 29440 var record = tryCatch(method, delegate.iterator, context.arg); 29441 if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; 29442 var info = record.arg; 29443 return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); 29444 } 29445 function pushTryEntry(locs) { 29446 var entry = { 29447 tryLoc: locs[0] 29448 }; 29449 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); 29450 } 29451 function resetTryEntry(entry) { 29452 var record = entry.completion || {}; 29453 record.type = "normal", delete record.arg, entry.completion = record; 29454 } 29455 function Context(tryLocsList) { 29456 this.tryEntries = [{ 29457 tryLoc: "root" 29458 }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); 29459 } 29460 function values(iterable) { 29461 if (iterable) { 29462 var iteratorMethod = iterable[iteratorSymbol]; 29463 if (iteratorMethod) return iteratorMethod.call(iterable); 29464 if ("function" == typeof iterable.next) return iterable; 29465 if (!isNaN(iterable.length)) { 29466 var i = -1, 29467 next = function next() { 29468 for (; ++i < iterable.length;) { 29469 if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; 29470 } 29471 return next.value = undefined, next.done = !0, next; 29472 }; 29473 return next.next = next; 29474 } 29475 } 29476 return { 29477 next: doneResult 29478 }; 29479 } 29480 function doneResult() { 29481 return { 29482 value: undefined, 29483 done: !0 29484 }; 29485 } 29486 return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { 29487 value: GeneratorFunctionPrototype, 29488 configurable: !0 29489 }), defineProperty(GeneratorFunctionPrototype, "constructor", { 29490 value: GeneratorFunction, 29491 configurable: !0 29492 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { 29493 var ctor = "function" == typeof genFun && genFun.constructor; 29494 return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); 29495 }, exports.mark = function (genFun) { 29496 return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; 29497 }, exports.awrap = function (arg) { 29498 return { 29499 __await: arg 29500 }; 29501 }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { 29502 return this; 29503 }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { 29504 void 0 === PromiseImpl && (PromiseImpl = Promise); 29505 var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); 29506 return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { 29507 return result.done ? result.value : iter.next(); 29508 }); 29509 }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { 29510 return this; 29511 }), define(Gp, "toString", function () { 29512 return "[object Generator]"; 29513 }), exports.keys = function (val) { 29514 var object = Object(val), 29515 keys = []; 29516 for (var key in object) { 29517 keys.push(key); 29518 } 29519 return keys.reverse(), function next() { 29520 for (; keys.length;) { 29521 var key = keys.pop(); 29522 if (key in object) return next.value = key, next.done = !1, next; 29523 } 29524 return next.done = !0, next; 29525 }; 29526 }, exports.values = values, Context.prototype = { 29527 constructor: Context, 29528 reset: function reset(skipTempReset) { 29529 if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) { 29530 "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); 29531 } 29532 }, 29533 stop: function stop() { 29534 this.done = !0; 29535 var rootRecord = this.tryEntries[0].completion; 29536 if ("throw" === rootRecord.type) throw rootRecord.arg; 29537 return this.rval; 29538 }, 29539 dispatchException: function dispatchException(exception) { 29540 if (this.done) throw exception; 29541 var context = this; 29542 function handle(loc, caught) { 29543 return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; 29544 } 29545 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 29546 var entry = this.tryEntries[i], 29547 record = entry.completion; 29548 if ("root" === entry.tryLoc) return handle("end"); 29549 if (entry.tryLoc <= this.prev) { 29550 var hasCatch = hasOwn.call(entry, "catchLoc"), 29551 hasFinally = hasOwn.call(entry, "finallyLoc"); 29552 if (hasCatch && hasFinally) { 29553 if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); 29554 if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); 29555 } else if (hasCatch) { 29556 if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); 29557 } else { 29558 if (!hasFinally) throw new Error("try statement without catch or finally"); 29559 if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); 29560 } 29561 } 29562 } 29563 }, 29564 abrupt: function abrupt(type, arg) { 29565 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 29566 var entry = this.tryEntries[i]; 29567 if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { 29568 var finallyEntry = entry; 29569 break; 29570 } 29571 } 29572 finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); 29573 var record = finallyEntry ? finallyEntry.completion : {}; 29574 return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); 29575 }, 29576 complete: function complete(record, afterLoc) { 29577 if ("throw" === record.type) throw record.arg; 29578 return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; 29579 }, 29580 finish: function finish(finallyLoc) { 29581 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 29582 var entry = this.tryEntries[i]; 29583 if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; 29584 } 29585 }, 29586 "catch": function _catch(tryLoc) { 29587 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 29588 var entry = this.tryEntries[i]; 29589 if (entry.tryLoc === tryLoc) { 29590 var record = entry.completion; 29591 if ("throw" === record.type) { 29592 var thrown = record.arg; 29593 resetTryEntry(entry); 29594 } 29595 return thrown; 29596 } 29597 } 29598 throw new Error("illegal catch attempt"); 29599 }, 29600 delegateYield: function delegateYield(iterable, resultName, nextLoc) { 29601 return this.delegate = { 29602 iterator: values(iterable), 29603 resultName: resultName, 29604 nextLoc: nextLoc 29605 }, "next" === this.method && (this.arg = undefined), ContinueSentinel; 29606 } 29607 }, exports; 29608} 29609 29610/***/ }), 29611
vendor: 947 bytes, lines 29612-29634
29612/***/ "./node_modules/@babel/runtime/helpers/esm/typeof.js": 29613/*!***********************************************************!*\ 29614 !*** ./node_modules/@babel/runtime/helpers/esm/typeof.js ***! 29615 \***********************************************************/ 29616/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 29617 29618"use strict"; 29619__webpack_require__.r(__webpack_exports__); 29620/* harmony export */ __webpack_require__.d(__webpack_exports__, { 29621/* harmony export */ "default": function() { return /* binding */ _typeof; } 29622/* harmony export */ }); 29623function _typeof(obj) { 29624 "@babel/helpers - typeof"; 29625 29626 return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { 29627 return typeof obj; 29628 } : function (obj) { 29629 return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 29630 }, _typeof(obj); 29631} 29632 29633/***/ }), 29634
vendor: 20,253 bytes, lines 29635-29828
29635/***/ "./node_modules/vue-demi/lib/index.mjs": 29636/*!*********************************************!*\ 29637 !*** ./node_modules/vue-demi/lib/index.mjs ***! 29638 \*********************************************/ 29639/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 29640 29641"use strict"; 29642__webpack_require__.r(__webpack_exports__); 29643/* harmony export */ __webpack_require__.d(__webpack_exports__, { 29644/* harmony export */ "BaseTransition": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.BaseTransition; }, 29645/* harmony export */ "Comment": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Comment; }, 29646/* harmony export */ "EffectScope": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.EffectScope; }, 29647/* harmony export */ "Fragment": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Fragment; }, 29648/* harmony export */ "KeepAlive": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.KeepAlive; }, 29649/* harmony export */ "ReactiveEffect": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect; }, 29650/* harmony export */ "Static": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Static; }, 29651/* harmony export */ "Suspense": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Suspense; }, 29652/* harmony export */ "Teleport": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Teleport; }, 29653/* harmony export */ "Text": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Text; }, 29654/* harmony export */ "Transition": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.Transition; }, 29655/* harmony export */ "TransitionGroup": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.TransitionGroup; }, 29656/* harmony export */ "Vue": function() { return /* reexport module object */ vue__WEBPACK_IMPORTED_MODULE_0__; }, 29657/* harmony export */ "Vue2": function() { return /* binding */ Vue2; }, 29658/* harmony export */ "VueElement": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.VueElement; }, 29659/* harmony export */ "callWithAsyncErrorHandling": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling; }, 29660/* harmony export */ "callWithErrorHandling": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.callWithErrorHandling; }, 29661/* harmony export */ "camelize": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.camelize; }, 29662/* harmony export */ "capitalize": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.capitalize; }, 29663/* harmony export */ "cloneVNode": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.cloneVNode; }, 29664/* harmony export */ "compatUtils": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.compatUtils; }, 29665/* harmony export */ "compile": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.compile; }, 29666/* harmony export */ "computed": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.computed; }, 29667/* harmony export */ "createApp": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createApp; }, 29668/* harmony export */ "createBlock": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createBlock; }, 29669/* harmony export */ "createCommentVNode": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode; }, 29670/* harmony export */ "createElementBlock": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock; }, 29671/* harmony export */ "createElementVNode": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode; }, 29672/* harmony export */ "createHydrationRenderer": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer; }, 29673/* harmony export */ "createPropsRestProxy": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createPropsRestProxy; }, 29674/* harmony export */ "createRenderer": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createRenderer; }, 29675/* harmony export */ "createSSRApp": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createSSRApp; }, 29676/* harmony export */ "createSlots": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createSlots; }, 29677/* harmony export */ "createStaticVNode": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode; }, 29678/* harmony export */ "createTextVNode": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode; }, 29679/* harmony export */ "createVNode": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.createVNode; }, 29680/* harmony export */ "customRef": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.customRef; }, 29681/* harmony export */ "defineAsyncComponent": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineAsyncComponent; }, 29682/* harmony export */ "defineComponent": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent; }, 29683/* harmony export */ "defineCustomElement": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineCustomElement; }, 29684/* harmony export */ "defineEmits": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineEmits; }, 29685/* harmony export */ "defineExpose": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineExpose; }, 29686/* harmony export */ "defineProps": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineProps; }, 29687/* harmony export */ "defineSSRCustomElement": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.defineSSRCustomElement; }, 29688/* harmony export */ "del": function() { return /* binding */ del; }, 29689/* harmony export */ "devtools": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.devtools; }, 29690/* harmony export */ "effect": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.effect; }, 29691/* harmony export */ "effectScope": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.effectScope; }, 29692/* harmony export */ "getCurrentInstance": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance; }, 29693/* harmony export */ "getCurrentScope": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope; }, 29694/* harmony export */ "getTransitionRawChildren": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren; }, 29695/* harmony export */ "guardReactiveProps": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.guardReactiveProps; }, 29696/* harmony export */ "h": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.h; }, 29697/* harmony export */ "handleError": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.handleError; }, 29698/* harmony export */ "hydrate": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.hydrate; }, 29699/* harmony export */ "initCustomFormatter": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.initCustomFormatter; }, 29700/* harmony export */ "initDirectivesForSSR": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.initDirectivesForSSR; }, 29701/* harmony export */ "inject": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.inject; }, 29702/* harmony export */ "install": function() { return /* binding */ install; }, 29703/* harmony export */ "isMemoSame": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isMemoSame; }, 29704/* harmony export */ "isProxy": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isProxy; }, 29705/* harmony export */ "isReactive": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isReactive; }, 29706/* harmony export */ "isReadonly": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isReadonly; }, 29707/* harmony export */ "isRef": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isRef; }, 29708/* harmony export */ "isRuntimeOnly": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly; }, 29709/* harmony export */ "isShallow": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isShallow; }, 29710/* harmony export */ "isVNode": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.isVNode; }, 29711/* harmony export */ "isVue2": function() { return /* binding */ isVue2; }, 29712/* harmony export */ "isVue3": function() { return /* binding */ isVue3; }, 29713/* harmony export */ "markRaw": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.markRaw; }, 29714/* harmony export */ "mergeDefaults": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.mergeDefaults; }, 29715/* harmony export */ "mergeProps": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.mergeProps; }, 29716/* harmony export */ "nextTick": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.nextTick; }, 29717/* harmony export */ "normalizeClass": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass; }, 29718/* harmony export */ "normalizeProps": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.normalizeProps; }, 29719/* harmony export */ "normalizeStyle": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle; }, 29720/* harmony export */ "onActivated": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onActivated; }, 29721/* harmony export */ "onBeforeMount": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount; }, 29722/* harmony export */ "onBeforeUnmount": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount; }, 29723/* harmony export */ "onBeforeUpdate": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onBeforeUpdate; }, 29724/* harmony export */ "onDeactivated": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onDeactivated; }, 29725/* harmony export */ "onErrorCaptured": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onErrorCaptured; }, 29726/* harmony export */ "onMounted": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onMounted; }, 29727/* harmony export */ "onRenderTracked": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onRenderTracked; }, 29728/* harmony export */ "onRenderTriggered": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onRenderTriggered; }, 29729/* harmony export */ "onScopeDispose": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose; }, 29730/* harmony export */ "onServerPrefetch": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onServerPrefetch; }, 29731/* harmony export */ "onUnmounted": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted; }, 29732/* harmony export */ "onUpdated": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.onUpdated; }, 29733/* harmony export */ "openBlock": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.openBlock; }, 29734/* harmony export */ "popScopeId": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.popScopeId; }, 29735/* harmony export */ "provide": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.provide; }, 29736/* harmony export */ "proxyRefs": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.proxyRefs; }, 29737/* harmony export */ "pushScopeId": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.pushScopeId; }, 29738/* harmony export */ "queuePostFlushCb": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.queuePostFlushCb; }, 29739/* harmony export */ "reactive": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.reactive; }, 29740/* harmony export */ "readonly": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.readonly; }, 29741/* harmony export */ "ref": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.ref; }, 29742/* harmony export */ "registerRuntimeCompiler": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeCompiler; }, 29743/* harmony export */ "render": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.render; }, 29744/* harmony export */ "renderList": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.renderList; }, 29745/* harmony export */ "renderSlot": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot; }, 29746/* harmony export */ "resolveComponent": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.resolveComponent; }, 29747/* harmony export */ "resolveDirective": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective; }, 29748/* harmony export */ "resolveDynamicComponent": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent; }, 29749/* harmony export */ "resolveFilter": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.resolveFilter; }, 29750/* harmony export */ "resolveTransitionHooks": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks; }, 29751/* harmony export */ "set": function() { return /* binding */ set; }, 29752/* harmony export */ "setBlockTracking": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.setBlockTracking; }, 29753/* harmony export */ "setDevtoolsHook": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.setDevtoolsHook; }, 29754/* harmony export */ "setTransitionHooks": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks; }, 29755/* harmony export */ "shallowReactive": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.shallowReactive; }, 29756/* harmony export */ "shallowReadonly": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly; }, 29757/* harmony export */ "shallowRef": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.shallowRef; }, 29758/* harmony export */ "ssrContextKey": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.ssrContextKey; }, 29759/* harmony export */ "ssrUtils": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.ssrUtils; }, 29760/* harmony export */ "stop": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.stop; }, 29761/* harmony export */ "toDisplayString": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString; }, 29762/* harmony export */ "toHandlerKey": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey; }, 29763/* harmony export */ "toHandlers": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toHandlers; }, 29764/* harmony export */ "toRaw": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toRaw; }, 29765/* harmony export */ "toRef": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toRef; }, 29766/* harmony export */ "toRefs": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.toRefs; }, 29767/* harmony export */ "transformVNodeArgs": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.transformVNodeArgs; }, 29768/* harmony export */ "triggerRef": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.triggerRef; }, 29769/* harmony export */ "unref": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.unref; }, 29770/* harmony export */ "useAttrs": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useAttrs; }, 29771/* harmony export */ "useCssModule": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useCssModule; }, 29772/* harmony export */ "useCssVars": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useCssVars; }, 29773/* harmony export */ "useSSRContext": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useSSRContext; }, 29774/* harmony export */ "useSlots": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useSlots; }, 29775/* harmony export */ "useTransitionState": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.useTransitionState; }, 29776/* harmony export */ "vModelCheckbox": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vModelCheckbox; }, 29777/* harmony export */ "vModelDynamic": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vModelDynamic; }, 29778/* harmony export */ "vModelRadio": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vModelRadio; }, 29779/* harmony export */ "vModelSelect": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect; }, 29780/* harmony export */ "vModelText": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vModelText; }, 29781/* harmony export */ "vShow": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.vShow; }, 29782/* harmony export */ "version": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.version; }, 29783/* harmony export */ "warn": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.warn; }, 29784/* harmony export */ "watch": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.watch; }, 29785/* harmony export */ "watchEffect": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.watchEffect; }, 29786/* harmony export */ "watchPostEffect": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.watchPostEffect; }, 29787/* harmony export */ "watchSyncEffect": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.watchSyncEffect; }, 29788/* harmony export */ "withAsyncContext": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withAsyncContext; }, 29789/* harmony export */ "withCtx": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withCtx; }, 29790/* harmony export */ "withDefaults": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withDefaults; }, 29791/* harmony export */ "withDirectives": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives; }, 29792/* harmony export */ "withKeys": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withKeys; }, 29793/* harmony export */ "withMemo": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withMemo; }, 29794/* harmony export */ "withModifiers": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers; }, 29795/* harmony export */ "withScopeId": function() { return /* reexport safe */ vue__WEBPACK_IMPORTED_MODULE_0__.withScopeId; } 29796/* harmony export */ }); 29797/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.esm-bundler.js"); 29798 29799 29800var isVue2 = false 29801var isVue3 = true 29802var Vue2 = undefined 29803 29804function install() {} 29805 29806function set(target, key, val) { 29807 if (Array.isArray(target)) { 29808 target.length = Math.max(target.length, key) 29809 target.splice(key, 1, val) 29810 return val 29811 } 29812 target[key] = val 29813 return val 29814} 29815 29816function del(target, key) { 29817 if (Array.isArray(target)) { 29818 target.splice(key, 1) 29819 return 29820 } 29821 delete target[key] 29822} 29823 29824 29825 29826 29827 29828/***/ })
29828 29829 29830/******/ }); 29831/************************************************************************/ 29832/******/ // The module cache 29833/******/ var __webpack_module_cache__ = {}; 29834/******/ 29835/******/ // The require function 29836/******/ function __webpack_require__(moduleId) { 29837/******/ // Check if module is in cache 29838/******/ var cachedModule = __webpack_module_cache__[moduleId]; 29839/******/ if (cachedModule !== undefined) { 29840/******/ return cachedModule.exports; 29841/******/ } 29842/******/ // Create a new module (and put it into the cache) 29843/******/ var module = __webpack_module_cache__[moduleId] = { 29844/******/ id: moduleId, 29845/******/ loaded: false, 29846/******/ exports: {} 29847/******/ }; 29848/******/ 29849/******/ // Execute the module function 29850/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); 29851/******/ 29852/******/ // Flag the module as loaded 29853/******/ module.loaded = true; 29854/******/ 29855/******/ // Return the exports of the module 29856/******/ return module.exports; 29857/******/ } 29858/******/ 29859/************************************************************************/ 29860/******/ /* webpack/runtime/amd options */ 29861/******/ !function() { 29862/******/ __webpack_require__.amdO = {}; 29863/******/ }(); 29864/******/ 29865/******/ /* webpack/runtime/compat get default export */ 29866/******/ !function() { 29867/******/ // getDefaultExport function for compatibility with non-harmony modules 29868/******/ __webpack_require__.n = function(module) { 29869/******/ var getter = module && module.__esModule ? 29870/******/ function() { return module['default']; } : 29871/******/ function() { return module; }; 29872/******/ __webpack_require__.d(getter, { a: getter }); 29873/******/ return getter; 29874/******/ }; 29875/******/ }(); 29876/******/ 29877/******/ /* webpack/runtime/define property getters */ 29878/******/ !function() { 29879/******/ // define getter functions for harmony exports 29880/******/ __webpack_require__.d = function(exports, definition) { 29881/******/ for(var key in definition) { 29882/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 29883/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 29884/******/ } 29885/******/ } 29886/******/ }; 29887/******/ }(); 29888/******/ 29889/******/ /* webpack/runtime/global */ 29890/******/ !function() { 29891/******/ __webpack_require__.g = (function() { 29892/******/ if (typeof globalThis === 'object') return globalThis; 29893/******/ try { 29894/******/ return this || new Function('return this')(); 29895/******/ } catch (e) { 29896/******/ if (typeof window === 'object') return window; 29897/******/ } 29898/******/ })(); 29899/******/ }(); 29900/******/ 29901/******/ /* webpack/runtime/harmony module decorator */ 29902/******/ !function() { 29903/******/ __webpack_require__.hmd = function(module) { 29904/******/ module = Object.create(module); 29905/******/ if (!module.children) module.children = []; 29906/******/ Object.defineProperty(module, 'exports', { 29907/******/ enumerable: true, 29908/******/ set: function() { 29909/******/ throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id); 29910/******/ } 29911/******/ }); 29912/******/ return module; 29913/******/ }; 29914/******/ }(); 29915/******/ 29916/******/ /* webpack/runtime/hasOwnProperty shorthand */ 29917/******/ !function() { 29918/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } 29919/******/ }(); 29920/******/ 29921/******/ /* webpack/runtime/make namespace object */ 29922/******/ !function() { 29923/******/ // define __esModule on exports 29924/******/ __webpack_require__.r = function(exports) { 29925/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 29926/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 29927/******/ } 29928/******/ Object.defineProperty(exports, '__esModule', { value: true }); 29929/******/ }; 29930/******/ }(); 29931/******/ 29932/******/ /* webpack/runtime/nonce */ 29933/******/ !function() { 29934/******/ __webpack_require__.nc = undefined; 29935/******/ }(); 29936/******/ 29937/************************************************************************/ 29938var __webpack_exports__ = {}; 29939// This entry need to be wrapped in an IIFE because it need to be in strict mode. 29940!function() { 29941"use strict"; 29942/*!**************************************!*\ 29943 !*** ./resources/assets/js/logon.js ***! 29944 \**************************************/ 29945__webpack_require__.r(__webpack_exports__); 29946/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.esm-bundler.js"); 29947/* harmony import */ var _components_logonForm_vue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./components/logonForm.vue */ "./resources/assets/js/components/logonForm.vue"); 29948/* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! axios */ "./node_modules/axios/index.js"); 29949/* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(axios__WEBPACK_IMPORTED_MODULE_2__); 29950/* harmony import */ var vue_axios__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! vue-axios */ "./node_modules/vue-axios/dist/vue-axios.esm.min.js"); 29951 29952 29953 29954 29955(axios__WEBPACK_IMPORTED_MODULE_2___default().defaults.headers.common["X-Requested-With"]) = 'XMLHttpRequest'; 29956(axios__WEBPACK_IMPORTED_MODULE_2___default().defaults.headers) = { 29957 'X-Requested-With': 'XMLHttpRequest', 29958 'Cache-Control': 'no-cache', 29959 'Pragma': 'no-cache', 29960 'Expires': '0' 29961}; 29962 29963/*****************************************************/ 29964var app = (0,vue__WEBPACK_IMPORTED_MODULE_0__.createApp)({}); 29965app.config.globalProperties.axios = (axios__WEBPACK_IMPORTED_MODULE_2___default()); 29966app.config.globalProperties.VueAxios = vue_axios__WEBPACK_IMPORTED_MODULE_3__["default"]; 29967 29968/*****************************************************/ 29969app.component('logon-form', _components_logonForm_vue__WEBPACK_IMPORTED_MODULE_1__["default"]); 29970app.mount('#logon-layer'); 29971}(); 29972/******/ })() 29973;
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.