{"version":3,"file":"js/chunk-vendors-4f852d99.91207b2d.js","mappings":"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","sources":["webpack://rokk3rfuel/./node_modules/@vue/devtools-api/lib/esm/env.js","webpack://rokk3rfuel/./node_modules/@vue/devtools-api/lib/esm/const.js","webpack://rokk3rfuel/./node_modules/@vue/devtools-api/lib/esm/time.js","webpack://rokk3rfuel/./node_modules/@vue/devtools-api/lib/esm/proxy.js","webpack://rokk3rfuel/./node_modules/@vue/devtools-api/lib/esm/index.js","webpack://rokk3rfuel/./node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js","webpack://rokk3rfuel/./node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js","webpack://rokk3rfuel/./node_modules/vue/dist/vue.esm-bundler.js","webpack://rokk3rfuel/./node_modules/vue3-timepicker/dist/VueTimepikcer.esm.js"],"sourcesContent":["export function getDevtoolsGlobalHook() {\n    return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;\n}\nexport function getTarget() {\n    // @ts-ignore\n    return (typeof navigator !== 'undefined' && typeof window !== 'undefined')\n        ? window\n        : typeof global !== 'undefined'\n            ? global\n            : {};\n}\nexport const isProxyAvailable = typeof Proxy === 'function';\n","export const HOOK_SETUP = 'devtools-plugin:setup';\nexport const HOOK_PLUGIN_SETTINGS_SET = 'plugin:settings:set';\n","let supported;\nlet perf;\nexport function isPerformanceSupported() {\n    var _a;\n    if (supported !== undefined) {\n        return supported;\n    }\n    if (typeof window !== 'undefined' && window.performance) {\n        supported = true;\n        perf = window.performance;\n    }\n    else if (typeof global !== 'undefined' && ((_a = global.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) {\n        supported = true;\n        perf = global.perf_hooks.performance;\n    }\n    else {\n        supported = false;\n    }\n    return supported;\n}\nexport function now() {\n    return isPerformanceSupported() ? perf.now() : Date.now();\n}\n","import { HOOK_PLUGIN_SETTINGS_SET } from './const.js';\nimport { now } from './time.js';\nexport class ApiProxy {\n    constructor(plugin, hook) {\n        this.target = null;\n        this.targetQueue = [];\n        this.onQueue = [];\n        this.plugin = plugin;\n        this.hook = hook;\n        const defaultSettings = {};\n        if (plugin.settings) {\n            for (const id in plugin.settings) {\n                const item = plugin.settings[id];\n                defaultSettings[id] = item.defaultValue;\n            }\n        }\n        const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;\n        let currentSettings = Object.assign({}, defaultSettings);\n        try {\n            const raw = localStorage.getItem(localSettingsSaveId);\n            const data = JSON.parse(raw);\n            Object.assign(currentSettings, data);\n        }\n        catch (e) {\n            // noop\n        }\n        this.fallbacks = {\n            getSettings() {\n                return currentSettings;\n            },\n            setSettings(value) {\n                try {\n                    localStorage.setItem(localSettingsSaveId, JSON.stringify(value));\n                }\n                catch (e) {\n                    // noop\n                }\n                currentSettings = value;\n            },\n            now() {\n                return now();\n            },\n        };\n        if (hook) {\n            hook.on(HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {\n                if (pluginId === this.plugin.id) {\n                    this.fallbacks.setSettings(value);\n                }\n            });\n        }\n        this.proxiedOn = new Proxy({}, {\n            get: (_target, prop) => {\n                if (this.target) {\n                    return this.target.on[prop];\n                }\n                else {\n                    return (...args) => {\n                        this.onQueue.push({\n                            method: prop,\n                            args,\n                        });\n                    };\n                }\n            },\n        });\n        this.proxiedTarget = new Proxy({}, {\n            get: (_target, prop) => {\n                if (this.target) {\n                    return this.target[prop];\n                }\n                else if (prop === 'on') {\n                    return this.proxiedOn;\n                }\n                else if (Object.keys(this.fallbacks).includes(prop)) {\n                    return (...args) => {\n                        this.targetQueue.push({\n                            method: prop,\n                            args,\n                            resolve: () => { },\n                        });\n                        return this.fallbacks[prop](...args);\n                    };\n                }\n                else {\n                    return (...args) => {\n                        return new Promise(resolve => {\n                            this.targetQueue.push({\n                                method: prop,\n                                args,\n                                resolve,\n                            });\n                        });\n                    };\n                }\n            },\n        });\n    }\n    async setRealTarget(target) {\n        this.target = target;\n        for (const item of this.onQueue) {\n            this.target.on[item.method](...item.args);\n        }\n        for (const item of this.targetQueue) {\n            item.resolve(await this.target[item.method](...item.args));\n        }\n    }\n}\n","import { getTarget, getDevtoolsGlobalHook, isProxyAvailable } from './env.js';\nimport { HOOK_SETUP } from './const.js';\nimport { ApiProxy } from './proxy.js';\nexport * from './api/index.js';\nexport * from './plugin.js';\nexport * from './time.js';\nexport function setupDevtoolsPlugin(pluginDescriptor, setupFn) {\n    const descriptor = pluginDescriptor;\n    const target = getTarget();\n    const hook = getDevtoolsGlobalHook();\n    const enableProxy = isProxyAvailable && descriptor.enableEarlyProxy;\n    if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {\n        hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);\n    }\n    else {\n        const proxy = enableProxy ? new ApiProxy(descriptor, hook) : null;\n        const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];\n        list.push({\n            pluginDescriptor: descriptor,\n            setupFn,\n            proxy,\n        });\n        if (proxy)\n            setupFn(proxy.proxiedTarget);\n    }\n}\n","import { isString, hyphenate, NOOP, extend, isObject, NO, isArray, makeMap, isSymbol, EMPTY_OBJ, capitalize, camelize as camelize$1, PatchFlagNames, slotFlagsText, isOn, isBuiltInDirective, isReservedProp, toHandlerKey } from '@vue/shared';\nexport { generateCodeFrame } from '@vue/shared';\n\nfunction defaultOnError(error) {\n    throw error;\n}\nfunction defaultOnWarn(msg) {\n    (process.env.NODE_ENV !== 'production') && console.warn(`[Vue warn] ${msg.message}`);\n}\nfunction createCompilerError(code, loc, messages, additionalMessage) {\n    const msg = (process.env.NODE_ENV !== 'production') || !true\n        ? (messages || errorMessages)[code] + (additionalMessage || ``)\n        : code;\n    const error = new SyntaxError(String(msg));\n    error.code = code;\n    error.loc = loc;\n    return error;\n}\nconst errorMessages = {\n    // parse errors\n    [0 /* ErrorCodes.ABRUPT_CLOSING_OF_EMPTY_COMMENT */]: 'Illegal comment.',\n    [1 /* ErrorCodes.CDATA_IN_HTML_CONTENT */]: 'CDATA section is allowed only in XML context.',\n    [2 /* ErrorCodes.DUPLICATE_ATTRIBUTE */]: 'Duplicate attribute.',\n    [3 /* ErrorCodes.END_TAG_WITH_ATTRIBUTES */]: 'End tag cannot have attributes.',\n    [4 /* ErrorCodes.END_TAG_WITH_TRAILING_SOLIDUS */]: \"Illegal '/' in tags.\",\n    [5 /* ErrorCodes.EOF_BEFORE_TAG_NAME */]: 'Unexpected EOF in tag.',\n    [6 /* ErrorCodes.EOF_IN_CDATA */]: 'Unexpected EOF in CDATA section.',\n    [7 /* ErrorCodes.EOF_IN_COMMENT */]: 'Unexpected EOF in comment.',\n    [8 /* ErrorCodes.EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT */]: 'Unexpected EOF in script.',\n    [9 /* ErrorCodes.EOF_IN_TAG */]: 'Unexpected EOF in tag.',\n    [10 /* ErrorCodes.INCORRECTLY_CLOSED_COMMENT */]: 'Incorrectly closed comment.',\n    [11 /* ErrorCodes.INCORRECTLY_OPENED_COMMENT */]: 'Incorrectly opened comment.',\n    [12 /* ErrorCodes.INVALID_FIRST_CHARACTER_OF_TAG_NAME */]: \"Illegal tag name. Use '&lt;' to print '<'.\",\n    [13 /* ErrorCodes.MISSING_ATTRIBUTE_VALUE */]: 'Attribute value was expected.',\n    [14 /* ErrorCodes.MISSING_END_TAG_NAME */]: 'End tag name was expected.',\n    [15 /* ErrorCodes.MISSING_WHITESPACE_BETWEEN_ATTRIBUTES */]: 'Whitespace was expected.',\n    [16 /* ErrorCodes.NESTED_COMMENT */]: \"Unexpected '<!--' in comment.\",\n    [17 /* ErrorCodes.UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME */]: 'Attribute name cannot contain U+0022 (\"), U+0027 (\\'), and U+003C (<).',\n    [18 /* ErrorCodes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE */]: 'Unquoted attribute value cannot contain U+0022 (\"), U+0027 (\\'), U+003C (<), U+003D (=), and U+0060 (`).',\n    [19 /* ErrorCodes.UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME */]: \"Attribute name cannot start with '='.\",\n    [21 /* ErrorCodes.UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME */]: \"'<?' is allowed only in XML context.\",\n    [20 /* ErrorCodes.UNEXPECTED_NULL_CHARACTER */]: `Unexpected null character.`,\n    [22 /* ErrorCodes.UNEXPECTED_SOLIDUS_IN_TAG */]: \"Illegal '/' in tags.\",\n    // Vue-specific parse errors\n    [23 /* ErrorCodes.X_INVALID_END_TAG */]: 'Invalid end tag.',\n    [24 /* ErrorCodes.X_MISSING_END_TAG */]: 'Element is missing end tag.',\n    [25 /* ErrorCodes.X_MISSING_INTERPOLATION_END */]: 'Interpolation end sign was not found.',\n    [27 /* ErrorCodes.X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END */]: 'End bracket for dynamic directive argument was not found. ' +\n        'Note that dynamic directive argument cannot contain spaces.',\n    [26 /* ErrorCodes.X_MISSING_DIRECTIVE_NAME */]: 'Legal directive name was expected.',\n    // transform errors\n    [28 /* ErrorCodes.X_V_IF_NO_EXPRESSION */]: `v-if/v-else-if is missing expression.`,\n    [29 /* ErrorCodes.X_V_IF_SAME_KEY */]: `v-if/else branches must use unique keys.`,\n    [30 /* ErrorCodes.X_V_ELSE_NO_ADJACENT_IF */]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,\n    [31 /* ErrorCodes.X_V_FOR_NO_EXPRESSION */]: `v-for is missing expression.`,\n    [32 /* ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION */]: `v-for has invalid expression.`,\n    [33 /* ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT */]: `<template v-for> key should be placed on the <template> tag.`,\n    [34 /* ErrorCodes.X_V_BIND_NO_EXPRESSION */]: `v-bind is missing expression.`,\n    [35 /* ErrorCodes.X_V_ON_NO_EXPRESSION */]: `v-on is missing expression.`,\n    [36 /* ErrorCodes.X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */]: `Unexpected custom directive on <slot> outlet.`,\n    [37 /* ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE */]: `Mixed v-slot usage on both the component and nested <template>.` +\n        `When there are multiple named slots, all slots should use <template> ` +\n        `syntax to avoid scope ambiguity.`,\n    [38 /* ErrorCodes.X_V_SLOT_DUPLICATE_SLOT_NAMES */]: `Duplicate slot names found. `,\n    [39 /* ErrorCodes.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN */]: `Extraneous children found when component already has explicitly named ` +\n        `default slot. These children will be ignored.`,\n    [40 /* ErrorCodes.X_V_SLOT_MISPLACED */]: `v-slot can only be used on components or <template> tags.`,\n    [41 /* ErrorCodes.X_V_MODEL_NO_EXPRESSION */]: `v-model is missing expression.`,\n    [42 /* ErrorCodes.X_V_MODEL_MALFORMED_EXPRESSION */]: `v-model value must be a valid JavaScript member expression.`,\n    [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.`,\n    [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.`,\n    [45 /* ErrorCodes.X_INVALID_EXPRESSION */]: `Error parsing JavaScript expression: `,\n    [46 /* ErrorCodes.X_KEEP_ALIVE_INVALID_CHILDREN */]: `<KeepAlive> expects exactly one child component.`,\n    // generic errors\n    [47 /* ErrorCodes.X_PREFIX_ID_NOT_SUPPORTED */]: `\"prefixIdentifiers\" option is not supported in this build of compiler.`,\n    [48 /* ErrorCodes.X_MODULE_MODE_NOT_SUPPORTED */]: `ES module mode is not supported in this build of compiler.`,\n    [49 /* ErrorCodes.X_CACHE_HANDLER_NOT_SUPPORTED */]: `\"cacheHandlers\" option is only supported when the \"prefixIdentifiers\" option is enabled.`,\n    [50 /* ErrorCodes.X_SCOPE_ID_NOT_SUPPORTED */]: `\"scopeId\" option is only supported in module mode.`,\n    // just to fulfill types\n    [51 /* ErrorCodes.__EXTEND_POINT__ */]: ``\n};\n\nconst FRAGMENT = Symbol((process.env.NODE_ENV !== 'production') ? `Fragment` : ``);\nconst TELEPORT = Symbol((process.env.NODE_ENV !== 'production') ? `Teleport` : ``);\nconst SUSPENSE = Symbol((process.env.NODE_ENV !== 'production') ? `Suspense` : ``);\nconst KEEP_ALIVE = Symbol((process.env.NODE_ENV !== 'production') ? `KeepAlive` : ``);\nconst BASE_TRANSITION = Symbol((process.env.NODE_ENV !== 'production') ? `BaseTransition` : ``);\nconst OPEN_BLOCK = Symbol((process.env.NODE_ENV !== 'production') ? `openBlock` : ``);\nconst CREATE_BLOCK = Symbol((process.env.NODE_ENV !== 'production') ? `createBlock` : ``);\nconst CREATE_ELEMENT_BLOCK = Symbol((process.env.NODE_ENV !== 'production') ? `createElementBlock` : ``);\nconst CREATE_VNODE = Symbol((process.env.NODE_ENV !== 'production') ? `createVNode` : ``);\nconst CREATE_ELEMENT_VNODE = Symbol((process.env.NODE_ENV !== 'production') ? `createElementVNode` : ``);\nconst CREATE_COMMENT = Symbol((process.env.NODE_ENV !== 'production') ? `createCommentVNode` : ``);\nconst CREATE_TEXT = Symbol((process.env.NODE_ENV !== 'production') ? `createTextVNode` : ``);\nconst CREATE_STATIC = Symbol((process.env.NODE_ENV !== 'production') ? `createStaticVNode` : ``);\nconst RESOLVE_COMPONENT = Symbol((process.env.NODE_ENV !== 'production') ? `resolveComponent` : ``);\nconst RESOLVE_DYNAMIC_COMPONENT = Symbol((process.env.NODE_ENV !== 'production') ? `resolveDynamicComponent` : ``);\nconst RESOLVE_DIRECTIVE = Symbol((process.env.NODE_ENV !== 'production') ? `resolveDirective` : ``);\nconst RESOLVE_FILTER = Symbol((process.env.NODE_ENV !== 'production') ? `resolveFilter` : ``);\nconst WITH_DIRECTIVES = Symbol((process.env.NODE_ENV !== 'production') ? `withDirectives` : ``);\nconst RENDER_LIST = Symbol((process.env.NODE_ENV !== 'production') ? `renderList` : ``);\nconst RENDER_SLOT = Symbol((process.env.NODE_ENV !== 'production') ? `renderSlot` : ``);\nconst CREATE_SLOTS = Symbol((process.env.NODE_ENV !== 'production') ? `createSlots` : ``);\nconst TO_DISPLAY_STRING = Symbol((process.env.NODE_ENV !== 'production') ? `toDisplayString` : ``);\nconst MERGE_PROPS = Symbol((process.env.NODE_ENV !== 'production') ? `mergeProps` : ``);\nconst NORMALIZE_CLASS = Symbol((process.env.NODE_ENV !== 'production') ? `normalizeClass` : ``);\nconst NORMALIZE_STYLE = Symbol((process.env.NODE_ENV !== 'production') ? `normalizeStyle` : ``);\nconst NORMALIZE_PROPS = Symbol((process.env.NODE_ENV !== 'production') ? `normalizeProps` : ``);\nconst GUARD_REACTIVE_PROPS = Symbol((process.env.NODE_ENV !== 'production') ? `guardReactiveProps` : ``);\nconst TO_HANDLERS = Symbol((process.env.NODE_ENV !== 'production') ? `toHandlers` : ``);\nconst CAMELIZE = Symbol((process.env.NODE_ENV !== 'production') ? `camelize` : ``);\nconst CAPITALIZE = Symbol((process.env.NODE_ENV !== 'production') ? `capitalize` : ``);\nconst TO_HANDLER_KEY = Symbol((process.env.NODE_ENV !== 'production') ? `toHandlerKey` : ``);\nconst SET_BLOCK_TRACKING = Symbol((process.env.NODE_ENV !== 'production') ? `setBlockTracking` : ``);\nconst PUSH_SCOPE_ID = Symbol((process.env.NODE_ENV !== 'production') ? `pushScopeId` : ``);\nconst POP_SCOPE_ID = Symbol((process.env.NODE_ENV !== 'production') ? `popScopeId` : ``);\nconst WITH_CTX = Symbol((process.env.NODE_ENV !== 'production') ? `withCtx` : ``);\nconst UNREF = Symbol((process.env.NODE_ENV !== 'production') ? `unref` : ``);\nconst IS_REF = Symbol((process.env.NODE_ENV !== 'production') ? `isRef` : ``);\nconst WITH_MEMO = Symbol((process.env.NODE_ENV !== 'production') ? `withMemo` : ``);\nconst IS_MEMO_SAME = Symbol((process.env.NODE_ENV !== 'production') ? `isMemoSame` : ``);\n// Name mapping for runtime helpers that need to be imported from 'vue' in\n// generated code. Make sure these are correctly exported in the runtime!\nconst helperNameMap = {\n    [FRAGMENT]: `Fragment`,\n    [TELEPORT]: `Teleport`,\n    [SUSPENSE]: `Suspense`,\n    [KEEP_ALIVE]: `KeepAlive`,\n    [BASE_TRANSITION]: `BaseTransition`,\n    [OPEN_BLOCK]: `openBlock`,\n    [CREATE_BLOCK]: `createBlock`,\n    [CREATE_ELEMENT_BLOCK]: `createElementBlock`,\n    [CREATE_VNODE]: `createVNode`,\n    [CREATE_ELEMENT_VNODE]: `createElementVNode`,\n    [CREATE_COMMENT]: `createCommentVNode`,\n    [CREATE_TEXT]: `createTextVNode`,\n    [CREATE_STATIC]: `createStaticVNode`,\n    [RESOLVE_COMPONENT]: `resolveComponent`,\n    [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,\n    [RESOLVE_DIRECTIVE]: `resolveDirective`,\n    [RESOLVE_FILTER]: `resolveFilter`,\n    [WITH_DIRECTIVES]: `withDirectives`,\n    [RENDER_LIST]: `renderList`,\n    [RENDER_SLOT]: `renderSlot`,\n    [CREATE_SLOTS]: `createSlots`,\n    [TO_DISPLAY_STRING]: `toDisplayString`,\n    [MERGE_PROPS]: `mergeProps`,\n    [NORMALIZE_CLASS]: `normalizeClass`,\n    [NORMALIZE_STYLE]: `normalizeStyle`,\n    [NORMALIZE_PROPS]: `normalizeProps`,\n    [GUARD_REACTIVE_PROPS]: `guardReactiveProps`,\n    [TO_HANDLERS]: `toHandlers`,\n    [CAMELIZE]: `camelize`,\n    [CAPITALIZE]: `capitalize`,\n    [TO_HANDLER_KEY]: `toHandlerKey`,\n    [SET_BLOCK_TRACKING]: `setBlockTracking`,\n    [PUSH_SCOPE_ID]: `pushScopeId`,\n    [POP_SCOPE_ID]: `popScopeId`,\n    [WITH_CTX]: `withCtx`,\n    [UNREF]: `unref`,\n    [IS_REF]: `isRef`,\n    [WITH_MEMO]: `withMemo`,\n    [IS_MEMO_SAME]: `isMemoSame`\n};\nfunction registerRuntimeHelpers(helpers) {\n    Object.getOwnPropertySymbols(helpers).forEach(s => {\n        helperNameMap[s] = helpers[s];\n    });\n}\n\n// AST Utilities ---------------------------------------------------------------\n// Some expressions, e.g. sequence and conditional expressions, are never\n// associated with template nodes, so their source locations are just a stub.\n// Container types like CompoundExpression also don't need a real location.\nconst locStub = {\n    source: '',\n    start: { line: 1, column: 1, offset: 0 },\n    end: { line: 1, column: 1, offset: 0 }\n};\nfunction createRoot(children, loc = locStub) {\n    return {\n        type: 0 /* NodeTypes.ROOT */,\n        children,\n        helpers: [],\n        components: [],\n        directives: [],\n        hoists: [],\n        imports: [],\n        cached: 0,\n        temps: 0,\n        codegenNode: undefined,\n        loc\n    };\n}\nfunction createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {\n    if (context) {\n        if (isBlock) {\n            context.helper(OPEN_BLOCK);\n            context.helper(getVNodeBlockHelper(context.inSSR, isComponent));\n        }\n        else {\n            context.helper(getVNodeHelper(context.inSSR, isComponent));\n        }\n        if (directives) {\n            context.helper(WITH_DIRECTIVES);\n        }\n    }\n    return {\n        type: 13 /* NodeTypes.VNODE_CALL */,\n        tag,\n        props,\n        children,\n        patchFlag,\n        dynamicProps,\n        directives,\n        isBlock,\n        disableTracking,\n        isComponent,\n        loc\n    };\n}\nfunction createArrayExpression(elements, loc = locStub) {\n    return {\n        type: 17 /* NodeTypes.JS_ARRAY_EXPRESSION */,\n        loc,\n        elements\n    };\n}\nfunction createObjectExpression(properties, loc = locStub) {\n    return {\n        type: 15 /* NodeTypes.JS_OBJECT_EXPRESSION */,\n        loc,\n        properties\n    };\n}\nfunction createObjectProperty(key, value) {\n    return {\n        type: 16 /* NodeTypes.JS_PROPERTY */,\n        loc: locStub,\n        key: isString(key) ? createSimpleExpression(key, true) : key,\n        value\n    };\n}\nfunction createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0 /* ConstantTypes.NOT_CONSTANT */) {\n    return {\n        type: 4 /* NodeTypes.SIMPLE_EXPRESSION */,\n        loc,\n        content,\n        isStatic,\n        constType: isStatic ? 3 /* ConstantTypes.CAN_STRINGIFY */ : constType\n    };\n}\nfunction createInterpolation(content, loc) {\n    return {\n        type: 5 /* NodeTypes.INTERPOLATION */,\n        loc,\n        content: isString(content)\n            ? createSimpleExpression(content, false, loc)\n            : content\n    };\n}\nfunction createCompoundExpression(children, loc = locStub) {\n    return {\n        type: 8 /* NodeTypes.COMPOUND_EXPRESSION */,\n        loc,\n        children\n    };\n}\nfunction createCallExpression(callee, args = [], loc = locStub) {\n    return {\n        type: 14 /* NodeTypes.JS_CALL_EXPRESSION */,\n        loc,\n        callee,\n        arguments: args\n    };\n}\nfunction createFunctionExpression(params, returns = undefined, newline = false, isSlot = false, loc = locStub) {\n    return {\n        type: 18 /* NodeTypes.JS_FUNCTION_EXPRESSION */,\n        params,\n        returns,\n        newline,\n        isSlot,\n        loc\n    };\n}\nfunction createConditionalExpression(test, consequent, alternate, newline = true) {\n    return {\n        type: 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */,\n        test,\n        consequent,\n        alternate,\n        newline,\n        loc: locStub\n    };\n}\nfunction createCacheExpression(index, value, isVNode = false) {\n    return {\n        type: 20 /* NodeTypes.JS_CACHE_EXPRESSION */,\n        index,\n        value,\n        isVNode,\n        loc: locStub\n    };\n}\nfunction createBlockStatement(body) {\n    return {\n        type: 21 /* NodeTypes.JS_BLOCK_STATEMENT */,\n        body,\n        loc: locStub\n    };\n}\nfunction createTemplateLiteral(elements) {\n    return {\n        type: 22 /* NodeTypes.JS_TEMPLATE_LITERAL */,\n        elements,\n        loc: locStub\n    };\n}\nfunction createIfStatement(test, consequent, alternate) {\n    return {\n        type: 23 /* NodeTypes.JS_IF_STATEMENT */,\n        test,\n        consequent,\n        alternate,\n        loc: locStub\n    };\n}\nfunction createAssignmentExpression(left, right) {\n    return {\n        type: 24 /* NodeTypes.JS_ASSIGNMENT_EXPRESSION */,\n        left,\n        right,\n        loc: locStub\n    };\n}\nfunction createSequenceExpression(expressions) {\n    return {\n        type: 25 /* NodeTypes.JS_SEQUENCE_EXPRESSION */,\n        expressions,\n        loc: locStub\n    };\n}\nfunction createReturnStatement(returns) {\n    return {\n        type: 26 /* NodeTypes.JS_RETURN_STATEMENT */,\n        returns,\n        loc: locStub\n    };\n}\n\nconst isStaticExp = (p) => p.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && p.isStatic;\nconst isBuiltInType = (tag, expected) => tag === expected || tag === hyphenate(expected);\nfunction isCoreComponent(tag) {\n    if (isBuiltInType(tag, 'Teleport')) {\n        return TELEPORT;\n    }\n    else if (isBuiltInType(tag, 'Suspense')) {\n        return SUSPENSE;\n    }\n    else if (isBuiltInType(tag, 'KeepAlive')) {\n        return KEEP_ALIVE;\n    }\n    else if (isBuiltInType(tag, 'BaseTransition')) {\n        return BASE_TRANSITION;\n    }\n}\nconst nonIdentifierRE = /^\\d|[^\\$\\w]/;\nconst isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);\nconst validFirstIdentCharRE = /[A-Za-z_$\\xA0-\\uFFFF]/;\nconst validIdentCharRE = /[\\.\\?\\w$\\xA0-\\uFFFF]/;\nconst whitespaceRE = /\\s+[.[]\\s*|\\s*[.[]\\s+/g;\n/**\n * Simple lexer to check if an expression is a member expression. This is\n * lax and only checks validity at the root level (i.e. does not validate exps\n * inside square brackets), but it's ok since these are only used on template\n * expressions and false positives are invalid expressions in the first place.\n */\nconst isMemberExpressionBrowser = (path) => {\n    // remove whitespaces around . or [ first\n    path = path.trim().replace(whitespaceRE, s => s.trim());\n    let state = 0 /* MemberExpLexState.inMemberExp */;\n    let stateStack = [];\n    let currentOpenBracketCount = 0;\n    let currentOpenParensCount = 0;\n    let currentStringType = null;\n    for (let i = 0; i < path.length; i++) {\n        const char = path.charAt(i);\n        switch (state) {\n            case 0 /* MemberExpLexState.inMemberExp */:\n                if (char === '[') {\n                    stateStack.push(state);\n                    state = 1 /* MemberExpLexState.inBrackets */;\n                    currentOpenBracketCount++;\n                }\n                else if (char === '(') {\n                    stateStack.push(state);\n                    state = 2 /* MemberExpLexState.inParens */;\n                    currentOpenParensCount++;\n                }\n                else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {\n                    return false;\n                }\n                break;\n            case 1 /* MemberExpLexState.inBrackets */:\n                if (char === `'` || char === `\"` || char === '`') {\n                    stateStack.push(state);\n                    state = 3 /* MemberExpLexState.inString */;\n                    currentStringType = char;\n                }\n                else if (char === `[`) {\n                    currentOpenBracketCount++;\n                }\n                else if (char === `]`) {\n                    if (!--currentOpenBracketCount) {\n                        state = stateStack.pop();\n                    }\n                }\n                break;\n            case 2 /* MemberExpLexState.inParens */:\n                if (char === `'` || char === `\"` || char === '`') {\n                    stateStack.push(state);\n                    state = 3 /* MemberExpLexState.inString */;\n                    currentStringType = char;\n                }\n                else if (char === `(`) {\n                    currentOpenParensCount++;\n                }\n                else if (char === `)`) {\n                    // if the exp ends as a call then it should not be considered valid\n                    if (i === path.length - 1) {\n                        return false;\n                    }\n                    if (!--currentOpenParensCount) {\n                        state = stateStack.pop();\n                    }\n                }\n                break;\n            case 3 /* MemberExpLexState.inString */:\n                if (char === currentStringType) {\n                    state = stateStack.pop();\n                    currentStringType = null;\n                }\n                break;\n        }\n    }\n    return !currentOpenBracketCount && !currentOpenParensCount;\n};\nconst isMemberExpressionNode = NOOP\n    ;\nconst isMemberExpression = isMemberExpressionBrowser\n    ;\nfunction getInnerRange(loc, offset, length) {\n    const source = loc.source.slice(offset, offset + length);\n    const newLoc = {\n        source,\n        start: advancePositionWithClone(loc.start, loc.source, offset),\n        end: loc.end\n    };\n    if (length != null) {\n        newLoc.end = advancePositionWithClone(loc.start, loc.source, offset + length);\n    }\n    return newLoc;\n}\nfunction advancePositionWithClone(pos, source, numberOfCharacters = source.length) {\n    return advancePositionWithMutation(extend({}, pos), source, numberOfCharacters);\n}\n// advance by mutation without cloning (for performance reasons), since this\n// gets called a lot in the parser\nfunction advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {\n    let linesCount = 0;\n    let lastNewLinePos = -1;\n    for (let i = 0; i < numberOfCharacters; i++) {\n        if (source.charCodeAt(i) === 10 /* newline char code */) {\n            linesCount++;\n            lastNewLinePos = i;\n        }\n    }\n    pos.offset += numberOfCharacters;\n    pos.line += linesCount;\n    pos.column =\n        lastNewLinePos === -1\n            ? pos.column + numberOfCharacters\n            : numberOfCharacters - lastNewLinePos;\n    return pos;\n}\nfunction assert(condition, msg) {\n    /* istanbul ignore if */\n    if (!condition) {\n        throw new Error(msg || `unexpected compiler condition`);\n    }\n}\nfunction findDir(node, name, allowEmpty = false) {\n    for (let i = 0; i < node.props.length; i++) {\n        const p = node.props[i];\n        if (p.type === 7 /* NodeTypes.DIRECTIVE */ &&\n            (allowEmpty || p.exp) &&\n            (isString(name) ? p.name === name : name.test(p.name))) {\n            return p;\n        }\n    }\n}\nfunction findProp(node, name, dynamicOnly = false, allowEmpty = false) {\n    for (let i = 0; i < node.props.length; i++) {\n        const p = node.props[i];\n        if (p.type === 6 /* NodeTypes.ATTRIBUTE */) {\n            if (dynamicOnly)\n                continue;\n            if (p.name === name && (p.value || allowEmpty)) {\n                return p;\n            }\n        }\n        else if (p.name === 'bind' &&\n            (p.exp || allowEmpty) &&\n            isStaticArgOf(p.arg, name)) {\n            return p;\n        }\n    }\n}\nfunction isStaticArgOf(arg, name) {\n    return !!(arg && isStaticExp(arg) && arg.content === name);\n}\nfunction hasDynamicKeyVBind(node) {\n    return node.props.some(p => p.type === 7 /* NodeTypes.DIRECTIVE */ &&\n        p.name === 'bind' &&\n        (!p.arg || // v-bind=\"obj\"\n            p.arg.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */ || // v-bind:[_ctx.foo]\n            !p.arg.isStatic) // v-bind:[foo]\n    );\n}\nfunction isText(node) {\n    return node.type === 5 /* NodeTypes.INTERPOLATION */ || node.type === 2 /* NodeTypes.TEXT */;\n}\nfunction isVSlot(p) {\n    return p.type === 7 /* NodeTypes.DIRECTIVE */ && p.name === 'slot';\n}\nfunction isTemplateNode(node) {\n    return (node.type === 1 /* NodeTypes.ELEMENT */ && node.tagType === 3 /* ElementTypes.TEMPLATE */);\n}\nfunction isSlotOutlet(node) {\n    return node.type === 1 /* NodeTypes.ELEMENT */ && node.tagType === 2 /* ElementTypes.SLOT */;\n}\nfunction getVNodeHelper(ssr, isComponent) {\n    return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;\n}\nfunction getVNodeBlockHelper(ssr, isComponent) {\n    return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;\n}\nconst propsHelperSet = new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);\nfunction getUnnormalizedProps(props, callPath = []) {\n    if (props &&\n        !isString(props) &&\n        props.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) {\n        const callee = props.callee;\n        if (!isString(callee) && propsHelperSet.has(callee)) {\n            return getUnnormalizedProps(props.arguments[0], callPath.concat(props));\n        }\n    }\n    return [props, callPath];\n}\nfunction injectProp(node, prop, context) {\n    let propsWithInjection;\n    /**\n     * 1. mergeProps(...)\n     * 2. toHandlers(...)\n     * 3. normalizeProps(...)\n     * 4. normalizeProps(guardReactiveProps(...))\n     *\n     * we need to get the real props before normalization\n     */\n    let props = node.type === 13 /* NodeTypes.VNODE_CALL */ ? node.props : node.arguments[2];\n    let callPath = [];\n    let parentCall;\n    if (props &&\n        !isString(props) &&\n        props.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) {\n        const ret = getUnnormalizedProps(props);\n        props = ret[0];\n        callPath = ret[1];\n        parentCall = callPath[callPath.length - 1];\n    }\n    if (props == null || isString(props)) {\n        propsWithInjection = createObjectExpression([prop]);\n    }\n    else if (props.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) {\n        // merged props... add ours\n        // only inject key to object literal if it's the first argument so that\n        // if doesn't override user provided keys\n        const first = props.arguments[0];\n        if (!isString(first) && first.type === 15 /* NodeTypes.JS_OBJECT_EXPRESSION */) {\n            // #6631\n            if (!hasProp(prop, first)) {\n                first.properties.unshift(prop);\n            }\n        }\n        else {\n            if (props.callee === TO_HANDLERS) {\n                // #2366\n                propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [\n                    createObjectExpression([prop]),\n                    props\n                ]);\n            }\n            else {\n                props.arguments.unshift(createObjectExpression([prop]));\n            }\n        }\n        !propsWithInjection && (propsWithInjection = props);\n    }\n    else if (props.type === 15 /* NodeTypes.JS_OBJECT_EXPRESSION */) {\n        if (!hasProp(prop, props)) {\n            props.properties.unshift(prop);\n        }\n        propsWithInjection = props;\n    }\n    else {\n        // single v-bind with expression, return a merged replacement\n        propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [\n            createObjectExpression([prop]),\n            props\n        ]);\n        // in the case of nested helper call, e.g. `normalizeProps(guardReactiveProps(props))`,\n        // it will be rewritten as `normalizeProps(mergeProps({ key: 0 }, props))`,\n        // the `guardReactiveProps` will no longer be needed\n        if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {\n            parentCall = callPath[callPath.length - 2];\n        }\n    }\n    if (node.type === 13 /* NodeTypes.VNODE_CALL */) {\n        if (parentCall) {\n            parentCall.arguments[0] = propsWithInjection;\n        }\n        else {\n            node.props = propsWithInjection;\n        }\n    }\n    else {\n        if (parentCall) {\n            parentCall.arguments[0] = propsWithInjection;\n        }\n        else {\n            node.arguments[2] = propsWithInjection;\n        }\n    }\n}\n// check existing key to avoid overriding user provided keys\nfunction hasProp(prop, props) {\n    let result = false;\n    if (prop.key.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n        const propKeyName = prop.key.content;\n        result = props.properties.some(p => p.key.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ &&\n            p.key.content === propKeyName);\n    }\n    return result;\n}\nfunction toValidAssetId(name, type) {\n    // see issue#4422, we need adding identifier on validAssetId if variable `name` has specific character\n    return `_${type}_${name.replace(/[^\\w]/g, (searchValue, replaceValue) => {\n        return searchValue === '-' ? '_' : name.charCodeAt(replaceValue).toString();\n    })}`;\n}\n// Check if a node contains expressions that reference current context scope ids\nfunction hasScopeRef(node, ids) {\n    if (!node || Object.keys(ids).length === 0) {\n        return false;\n    }\n    switch (node.type) {\n        case 1 /* NodeTypes.ELEMENT */:\n            for (let i = 0; i < node.props.length; i++) {\n                const p = node.props[i];\n                if (p.type === 7 /* NodeTypes.DIRECTIVE */ &&\n                    (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) {\n                    return true;\n                }\n            }\n            return node.children.some(c => hasScopeRef(c, ids));\n        case 11 /* NodeTypes.FOR */:\n            if (hasScopeRef(node.source, ids)) {\n                return true;\n            }\n            return node.children.some(c => hasScopeRef(c, ids));\n        case 9 /* NodeTypes.IF */:\n            return node.branches.some(b => hasScopeRef(b, ids));\n        case 10 /* NodeTypes.IF_BRANCH */:\n            if (hasScopeRef(node.condition, ids)) {\n                return true;\n            }\n            return node.children.some(c => hasScopeRef(c, ids));\n        case 4 /* NodeTypes.SIMPLE_EXPRESSION */:\n            return (!node.isStatic &&\n                isSimpleIdentifier(node.content) &&\n                !!ids[node.content]);\n        case 8 /* NodeTypes.COMPOUND_EXPRESSION */:\n            return node.children.some(c => isObject(c) && hasScopeRef(c, ids));\n        case 5 /* NodeTypes.INTERPOLATION */:\n        case 12 /* NodeTypes.TEXT_CALL */:\n            return hasScopeRef(node.content, ids);\n        case 2 /* NodeTypes.TEXT */:\n        case 3 /* NodeTypes.COMMENT */:\n            return false;\n        default:\n            if ((process.env.NODE_ENV !== 'production')) ;\n            return false;\n    }\n}\nfunction getMemoedVNodeCall(node) {\n    if (node.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */ && node.callee === WITH_MEMO) {\n        return node.arguments[1].returns;\n    }\n    else {\n        return node;\n    }\n}\nfunction makeBlock(node, { helper, removeHelper, inSSR }) {\n    if (!node.isBlock) {\n        node.isBlock = true;\n        removeHelper(getVNodeHelper(inSSR, node.isComponent));\n        helper(OPEN_BLOCK);\n        helper(getVNodeBlockHelper(inSSR, node.isComponent));\n    }\n}\n\nconst deprecationData = {\n    [\"COMPILER_IS_ON_ELEMENT\" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */]: {\n        message: `Platform-native elements with \"is\" prop will no longer be ` +\n            `treated as components in Vue 3 unless the \"is\" value is explicitly ` +\n            `prefixed with \"vue:\".`,\n        link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`\n    },\n    [\"COMPILER_V_BIND_SYNC\" /* CompilerDeprecationTypes.COMPILER_V_BIND_SYNC */]: {\n        message: key => `.sync modifier for v-bind has been removed. Use v-model with ` +\n            `argument instead. \\`v-bind:${key}.sync\\` should be changed to ` +\n            `\\`v-model:${key}\\`.`,\n        link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`\n    },\n    [\"COMPILER_V_BIND_PROP\" /* CompilerDeprecationTypes.COMPILER_V_BIND_PROP */]: {\n        message: `.prop modifier for v-bind has been removed and no longer necessary. ` +\n            `Vue 3 will automatically set a binding as DOM property when appropriate.`\n    },\n    [\"COMPILER_V_BIND_OBJECT_ORDER\" /* CompilerDeprecationTypes.COMPILER_V_BIND_OBJECT_ORDER */]: {\n        message: `v-bind=\"obj\" usage is now order sensitive and behaves like JavaScript ` +\n            `object spread: it will now overwrite an existing non-mergeable attribute ` +\n            `that appears before v-bind in the case of conflict. ` +\n            `To retain 2.x behavior, move v-bind to make it the first attribute. ` +\n            `You can also suppress this warning if the usage is intended.`,\n        link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`\n    },\n    [\"COMPILER_V_ON_NATIVE\" /* CompilerDeprecationTypes.COMPILER_V_ON_NATIVE */]: {\n        message: `.native modifier for v-on has been removed as is no longer necessary.`,\n        link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`\n    },\n    [\"COMPILER_V_IF_V_FOR_PRECEDENCE\" /* CompilerDeprecationTypes.COMPILER_V_IF_V_FOR_PRECEDENCE */]: {\n        message: `v-if / v-for precedence when used on the same element has changed ` +\n            `in Vue 3: v-if now takes higher precedence and will no longer have ` +\n            `access to v-for scope variables. It is best to avoid the ambiguity ` +\n            `with <template> tags or use a computed property that filters v-for ` +\n            `data source.`,\n        link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`\n    },\n    [\"COMPILER_NATIVE_TEMPLATE\" /* CompilerDeprecationTypes.COMPILER_NATIVE_TEMPLATE */]: {\n        message: `<template> with no special directives will render as a native template ` +\n            `element instead of its inner content in Vue 3.`\n    },\n    [\"COMPILER_INLINE_TEMPLATE\" /* CompilerDeprecationTypes.COMPILER_INLINE_TEMPLATE */]: {\n        message: `\"inline-template\" has been removed in Vue 3.`,\n        link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`\n    },\n    [\"COMPILER_FILTER\" /* CompilerDeprecationTypes.COMPILER_FILTERS */]: {\n        message: `filters have been removed in Vue 3. ` +\n            `The \"|\" symbol will be treated as native JavaScript bitwise OR operator. ` +\n            `Use method calls or computed properties instead.`,\n        link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`\n    }\n};\nfunction getCompatValue(key, context) {\n    const config = context.options\n        ? context.options.compatConfig\n        : context.compatConfig;\n    const value = config && config[key];\n    if (key === 'MODE') {\n        return value || 3; // compiler defaults to v3 behavior\n    }\n    else {\n        return value;\n    }\n}\nfunction isCompatEnabled(key, context) {\n    const mode = getCompatValue('MODE', context);\n    const value = getCompatValue(key, context);\n    // in v3 mode, only enable if explicitly set to true\n    // otherwise enable for any non-false value\n    return mode === 3 ? value === true : value !== false;\n}\nfunction checkCompatEnabled(key, context, loc, ...args) {\n    const enabled = isCompatEnabled(key, context);\n    if ((process.env.NODE_ENV !== 'production') && enabled) {\n        warnDeprecation(key, context, loc, ...args);\n    }\n    return enabled;\n}\nfunction warnDeprecation(key, context, loc, ...args) {\n    const val = getCompatValue(key, context);\n    if (val === 'suppress-warning') {\n        return;\n    }\n    const { message, link } = deprecationData[key];\n    const msg = `(deprecation ${key}) ${typeof message === 'function' ? message(...args) : message}${link ? `\\n  Details: ${link}` : ``}`;\n    const err = new SyntaxError(msg);\n    err.code = key;\n    if (loc)\n        err.loc = loc;\n    context.onWarn(err);\n}\n\n// The default decoder only provides escapes for characters reserved as part of\n// the template syntax, and is only used if the custom renderer did not provide\n// a platform-specific decoder.\nconst decodeRE = /&(gt|lt|amp|apos|quot);/g;\nconst decodeMap = {\n    gt: '>',\n    lt: '<',\n    amp: '&',\n    apos: \"'\",\n    quot: '\"'\n};\nconst defaultParserOptions = {\n    delimiters: [`{{`, `}}`],\n    getNamespace: () => 0 /* Namespaces.HTML */,\n    getTextMode: () => 0 /* TextModes.DATA */,\n    isVoidTag: NO,\n    isPreTag: NO,\n    isCustomElement: NO,\n    decodeEntities: (rawText) => rawText.replace(decodeRE, (_, p1) => decodeMap[p1]),\n    onError: defaultOnError,\n    onWarn: defaultOnWarn,\n    comments: (process.env.NODE_ENV !== 'production')\n};\nfunction baseParse(content, options = {}) {\n    const context = createParserContext(content, options);\n    const start = getCursor(context);\n    return createRoot(parseChildren(context, 0 /* TextModes.DATA */, []), getSelection(context, start));\n}\nfunction createParserContext(content, rawOptions) {\n    const options = extend({}, defaultParserOptions);\n    let key;\n    for (key in rawOptions) {\n        // @ts-ignore\n        options[key] =\n            rawOptions[key] === undefined\n                ? defaultParserOptions[key]\n                : rawOptions[key];\n    }\n    return {\n        options,\n        column: 1,\n        line: 1,\n        offset: 0,\n        originalSource: content,\n        source: content,\n        inPre: false,\n        inVPre: false,\n        onWarn: options.onWarn\n    };\n}\nfunction parseChildren(context, mode, ancestors) {\n    const parent = last(ancestors);\n    const ns = parent ? parent.ns : 0 /* Namespaces.HTML */;\n    const nodes = [];\n    while (!isEnd(context, mode, ancestors)) {\n        const s = context.source;\n        let node = undefined;\n        if (mode === 0 /* TextModes.DATA */ || mode === 1 /* TextModes.RCDATA */) {\n            if (!context.inVPre && startsWith(s, context.options.delimiters[0])) {\n                // '{{'\n                node = parseInterpolation(context, mode);\n            }\n            else if (mode === 0 /* TextModes.DATA */ && s[0] === '<') {\n                // https://html.spec.whatwg.org/multipage/parsing.html#tag-open-state\n                if (s.length === 1) {\n                    emitError(context, 5 /* ErrorCodes.EOF_BEFORE_TAG_NAME */, 1);\n                }\n                else if (s[1] === '!') {\n                    // https://html.spec.whatwg.org/multipage/parsing.html#markup-declaration-open-state\n                    if (startsWith(s, '<!--')) {\n                        node = parseComment(context);\n                    }\n                    else if (startsWith(s, '<!DOCTYPE')) {\n                        // Ignore DOCTYPE by a limitation.\n                        node = parseBogusComment(context);\n                    }\n                    else if (startsWith(s, '<![CDATA[')) {\n                        if (ns !== 0 /* Namespaces.HTML */) {\n                            node = parseCDATA(context, ancestors);\n                        }\n                        else {\n                            emitError(context, 1 /* ErrorCodes.CDATA_IN_HTML_CONTENT */);\n                            node = parseBogusComment(context);\n                        }\n                    }\n                    else {\n                        emitError(context, 11 /* ErrorCodes.INCORRECTLY_OPENED_COMMENT */);\n                        node = parseBogusComment(context);\n                    }\n                }\n                else if (s[1] === '/') {\n                    // https://html.spec.whatwg.org/multipage/parsing.html#end-tag-open-state\n                    if (s.length === 2) {\n                        emitError(context, 5 /* ErrorCodes.EOF_BEFORE_TAG_NAME */, 2);\n                    }\n                    else if (s[2] === '>') {\n                        emitError(context, 14 /* ErrorCodes.MISSING_END_TAG_NAME */, 2);\n                        advanceBy(context, 3);\n                        continue;\n                    }\n                    else if (/[a-z]/i.test(s[2])) {\n                        emitError(context, 23 /* ErrorCodes.X_INVALID_END_TAG */);\n                        parseTag(context, 1 /* TagType.End */, parent);\n                        continue;\n                    }\n                    else {\n                        emitError(context, 12 /* ErrorCodes.INVALID_FIRST_CHARACTER_OF_TAG_NAME */, 2);\n                        node = parseBogusComment(context);\n                    }\n                }\n                else if (/[a-z]/i.test(s[1])) {\n                    node = parseElement(context, ancestors);\n                    // 2.x <template> with no directive compat\n                    if (isCompatEnabled(\"COMPILER_NATIVE_TEMPLATE\" /* CompilerDeprecationTypes.COMPILER_NATIVE_TEMPLATE */, context) &&\n                        node &&\n                        node.tag === 'template' &&\n                        !node.props.some(p => p.type === 7 /* NodeTypes.DIRECTIVE */ &&\n                            isSpecialTemplateDirective(p.name))) {\n                        (process.env.NODE_ENV !== 'production') &&\n                            warnDeprecation(\"COMPILER_NATIVE_TEMPLATE\" /* CompilerDeprecationTypes.COMPILER_NATIVE_TEMPLATE */, context, node.loc);\n                        node = node.children;\n                    }\n                }\n                else if (s[1] === '?') {\n                    emitError(context, 21 /* ErrorCodes.UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME */, 1);\n                    node = parseBogusComment(context);\n                }\n                else {\n                    emitError(context, 12 /* ErrorCodes.INVALID_FIRST_CHARACTER_OF_TAG_NAME */, 1);\n                }\n            }\n        }\n        if (!node) {\n            node = parseText(context, mode);\n        }\n        if (isArray(node)) {\n            for (let i = 0; i < node.length; i++) {\n                pushNode(nodes, node[i]);\n            }\n        }\n        else {\n            pushNode(nodes, node);\n        }\n    }\n    // Whitespace handling strategy like v2\n    let removedWhitespace = false;\n    if (mode !== 2 /* TextModes.RAWTEXT */ && mode !== 1 /* TextModes.RCDATA */) {\n        const shouldCondense = context.options.whitespace !== 'preserve';\n        for (let i = 0; i < nodes.length; i++) {\n            const node = nodes[i];\n            if (node.type === 2 /* NodeTypes.TEXT */) {\n                if (!context.inPre) {\n                    if (!/[^\\t\\r\\n\\f ]/.test(node.content)) {\n                        const prev = nodes[i - 1];\n                        const next = nodes[i + 1];\n                        // Remove if:\n                        // - the whitespace is the first or last node, or:\n                        // - (condense mode) the whitespace is between twos comments, or:\n                        // - (condense mode) the whitespace is between comment and element, or:\n                        // - (condense mode) the whitespace is between two elements AND contains newline\n                        if (!prev ||\n                            !next ||\n                            (shouldCondense &&\n                                ((prev.type === 3 /* NodeTypes.COMMENT */ &&\n                                    next.type === 3 /* NodeTypes.COMMENT */) ||\n                                    (prev.type === 3 /* NodeTypes.COMMENT */ &&\n                                        next.type === 1 /* NodeTypes.ELEMENT */) ||\n                                    (prev.type === 1 /* NodeTypes.ELEMENT */ &&\n                                        next.type === 3 /* NodeTypes.COMMENT */) ||\n                                    (prev.type === 1 /* NodeTypes.ELEMENT */ &&\n                                        next.type === 1 /* NodeTypes.ELEMENT */ &&\n                                        /[\\r\\n]/.test(node.content))))) {\n                            removedWhitespace = true;\n                            nodes[i] = null;\n                        }\n                        else {\n                            // Otherwise, the whitespace is condensed into a single space\n                            node.content = ' ';\n                        }\n                    }\n                    else if (shouldCondense) {\n                        // in condense mode, consecutive whitespaces in text are condensed\n                        // down to a single space.\n                        node.content = node.content.replace(/[\\t\\r\\n\\f ]+/g, ' ');\n                    }\n                }\n                else {\n                    // #6410 normalize windows newlines in <pre>:\n                    // in SSR, browsers normalize server-rendered \\r\\n into a single \\n\n                    // in the DOM\n                    node.content = node.content.replace(/\\r\\n/g, '\\n');\n                }\n            }\n            // Remove comment nodes if desired by configuration.\n            else if (node.type === 3 /* NodeTypes.COMMENT */ && !context.options.comments) {\n                removedWhitespace = true;\n                nodes[i] = null;\n            }\n        }\n        if (context.inPre && parent && context.options.isPreTag(parent.tag)) {\n            // remove leading newline per html spec\n            // https://html.spec.whatwg.org/multipage/grouping-content.html#the-pre-element\n            const first = nodes[0];\n            if (first && first.type === 2 /* NodeTypes.TEXT */) {\n                first.content = first.content.replace(/^\\r?\\n/, '');\n            }\n        }\n    }\n    return removedWhitespace ? nodes.filter(Boolean) : nodes;\n}\nfunction pushNode(nodes, node) {\n    if (node.type === 2 /* NodeTypes.TEXT */) {\n        const prev = last(nodes);\n        // Merge if both this and the previous node are text and those are\n        // consecutive. This happens for cases like \"a < b\".\n        if (prev &&\n            prev.type === 2 /* NodeTypes.TEXT */ &&\n            prev.loc.end.offset === node.loc.start.offset) {\n            prev.content += node.content;\n            prev.loc.end = node.loc.end;\n            prev.loc.source += node.loc.source;\n            return;\n        }\n    }\n    nodes.push(node);\n}\nfunction parseCDATA(context, ancestors) {\n    advanceBy(context, 9);\n    const nodes = parseChildren(context, 3 /* TextModes.CDATA */, ancestors);\n    if (context.source.length === 0) {\n        emitError(context, 6 /* ErrorCodes.EOF_IN_CDATA */);\n    }\n    else {\n        advanceBy(context, 3);\n    }\n    return nodes;\n}\nfunction parseComment(context) {\n    const start = getCursor(context);\n    let content;\n    // Regular comment.\n    const match = /--(\\!)?>/.exec(context.source);\n    if (!match) {\n        content = context.source.slice(4);\n        advanceBy(context, context.source.length);\n        emitError(context, 7 /* ErrorCodes.EOF_IN_COMMENT */);\n    }\n    else {\n        if (match.index <= 3) {\n            emitError(context, 0 /* ErrorCodes.ABRUPT_CLOSING_OF_EMPTY_COMMENT */);\n        }\n        if (match[1]) {\n            emitError(context, 10 /* ErrorCodes.INCORRECTLY_CLOSED_COMMENT */);\n        }\n        content = context.source.slice(4, match.index);\n        // Advancing with reporting nested comments.\n        const s = context.source.slice(0, match.index);\n        let prevIndex = 1, nestedIndex = 0;\n        while ((nestedIndex = s.indexOf('<!--', prevIndex)) !== -1) {\n            advanceBy(context, nestedIndex - prevIndex + 1);\n            if (nestedIndex + 4 < s.length) {\n                emitError(context, 16 /* ErrorCodes.NESTED_COMMENT */);\n            }\n            prevIndex = nestedIndex + 1;\n        }\n        advanceBy(context, match.index + match[0].length - prevIndex + 1);\n    }\n    return {\n        type: 3 /* NodeTypes.COMMENT */,\n        content,\n        loc: getSelection(context, start)\n    };\n}\nfunction parseBogusComment(context) {\n    const start = getCursor(context);\n    const contentStart = context.source[1] === '?' ? 1 : 2;\n    let content;\n    const closeIndex = context.source.indexOf('>');\n    if (closeIndex === -1) {\n        content = context.source.slice(contentStart);\n        advanceBy(context, context.source.length);\n    }\n    else {\n        content = context.source.slice(contentStart, closeIndex);\n        advanceBy(context, closeIndex + 1);\n    }\n    return {\n        type: 3 /* NodeTypes.COMMENT */,\n        content,\n        loc: getSelection(context, start)\n    };\n}\nfunction parseElement(context, ancestors) {\n    // Start tag.\n    const wasInPre = context.inPre;\n    const wasInVPre = context.inVPre;\n    const parent = last(ancestors);\n    const element = parseTag(context, 0 /* TagType.Start */, parent);\n    const isPreBoundary = context.inPre && !wasInPre;\n    const isVPreBoundary = context.inVPre && !wasInVPre;\n    if (element.isSelfClosing || context.options.isVoidTag(element.tag)) {\n        // #4030 self-closing <pre> tag\n        if (isPreBoundary) {\n            context.inPre = false;\n        }\n        if (isVPreBoundary) {\n            context.inVPre = false;\n        }\n        return element;\n    }\n    // Children.\n    ancestors.push(element);\n    const mode = context.options.getTextMode(element, parent);\n    const children = parseChildren(context, mode, ancestors);\n    ancestors.pop();\n    // 2.x inline-template compat\n    {\n        const inlineTemplateProp = element.props.find(p => p.type === 6 /* NodeTypes.ATTRIBUTE */ && p.name === 'inline-template');\n        if (inlineTemplateProp &&\n            checkCompatEnabled(\"COMPILER_INLINE_TEMPLATE\" /* CompilerDeprecationTypes.COMPILER_INLINE_TEMPLATE */, context, inlineTemplateProp.loc)) {\n            const loc = getSelection(context, element.loc.end);\n            inlineTemplateProp.value = {\n                type: 2 /* NodeTypes.TEXT */,\n                content: loc.source,\n                loc\n            };\n        }\n    }\n    element.children = children;\n    // End tag.\n    if (startsWithEndTagOpen(context.source, element.tag)) {\n        parseTag(context, 1 /* TagType.End */, parent);\n    }\n    else {\n        emitError(context, 24 /* ErrorCodes.X_MISSING_END_TAG */, 0, element.loc.start);\n        if (context.source.length === 0 && element.tag.toLowerCase() === 'script') {\n            const first = children[0];\n            if (first && startsWith(first.loc.source, '<!--')) {\n                emitError(context, 8 /* ErrorCodes.EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT */);\n            }\n        }\n    }\n    element.loc = getSelection(context, element.loc.start);\n    if (isPreBoundary) {\n        context.inPre = false;\n    }\n    if (isVPreBoundary) {\n        context.inVPre = false;\n    }\n    return element;\n}\nconst isSpecialTemplateDirective = /*#__PURE__*/ makeMap(`if,else,else-if,for,slot`);\nfunction parseTag(context, type, parent) {\n    // Tag open.\n    const start = getCursor(context);\n    const match = /^<\\/?([a-z][^\\t\\r\\n\\f />]*)/i.exec(context.source);\n    const tag = match[1];\n    const ns = context.options.getNamespace(tag, parent);\n    advanceBy(context, match[0].length);\n    advanceSpaces(context);\n    // save current state in case we need to re-parse attributes with v-pre\n    const cursor = getCursor(context);\n    const currentSource = context.source;\n    // check <pre> tag\n    if (context.options.isPreTag(tag)) {\n        context.inPre = true;\n    }\n    // Attributes.\n    let props = parseAttributes(context, type);\n    // check v-pre\n    if (type === 0 /* TagType.Start */ &&\n        !context.inVPre &&\n        props.some(p => p.type === 7 /* NodeTypes.DIRECTIVE */ && p.name === 'pre')) {\n        context.inVPre = true;\n        // reset context\n        extend(context, cursor);\n        context.source = currentSource;\n        // re-parse attrs and filter out v-pre itself\n        props = parseAttributes(context, type).filter(p => p.name !== 'v-pre');\n    }\n    // Tag close.\n    let isSelfClosing = false;\n    if (context.source.length === 0) {\n        emitError(context, 9 /* ErrorCodes.EOF_IN_TAG */);\n    }\n    else {\n        isSelfClosing = startsWith(context.source, '/>');\n        if (type === 1 /* TagType.End */ && isSelfClosing) {\n            emitError(context, 4 /* ErrorCodes.END_TAG_WITH_TRAILING_SOLIDUS */);\n        }\n        advanceBy(context, isSelfClosing ? 2 : 1);\n    }\n    if (type === 1 /* TagType.End */) {\n        return;\n    }\n    // 2.x deprecation checks\n    if ((process.env.NODE_ENV !== 'production') &&\n        isCompatEnabled(\"COMPILER_V_IF_V_FOR_PRECEDENCE\" /* CompilerDeprecationTypes.COMPILER_V_IF_V_FOR_PRECEDENCE */, context)) {\n        let hasIf = false;\n        let hasFor = false;\n        for (let i = 0; i < props.length; i++) {\n            const p = props[i];\n            if (p.type === 7 /* NodeTypes.DIRECTIVE */) {\n                if (p.name === 'if') {\n                    hasIf = true;\n                }\n                else if (p.name === 'for') {\n                    hasFor = true;\n                }\n            }\n            if (hasIf && hasFor) {\n                warnDeprecation(\"COMPILER_V_IF_V_FOR_PRECEDENCE\" /* CompilerDeprecationTypes.COMPILER_V_IF_V_FOR_PRECEDENCE */, context, getSelection(context, start));\n                break;\n            }\n        }\n    }\n    let tagType = 0 /* ElementTypes.ELEMENT */;\n    if (!context.inVPre) {\n        if (tag === 'slot') {\n            tagType = 2 /* ElementTypes.SLOT */;\n        }\n        else if (tag === 'template') {\n            if (props.some(p => p.type === 7 /* NodeTypes.DIRECTIVE */ && isSpecialTemplateDirective(p.name))) {\n                tagType = 3 /* ElementTypes.TEMPLATE */;\n            }\n        }\n        else if (isComponent(tag, props, context)) {\n            tagType = 1 /* ElementTypes.COMPONENT */;\n        }\n    }\n    return {\n        type: 1 /* NodeTypes.ELEMENT */,\n        ns,\n        tag,\n        tagType,\n        props,\n        isSelfClosing,\n        children: [],\n        loc: getSelection(context, start),\n        codegenNode: undefined // to be created during transform phase\n    };\n}\nfunction isComponent(tag, props, context) {\n    const options = context.options;\n    if (options.isCustomElement(tag)) {\n        return false;\n    }\n    if (tag === 'component' ||\n        /^[A-Z]/.test(tag) ||\n        isCoreComponent(tag) ||\n        (options.isBuiltInComponent && options.isBuiltInComponent(tag)) ||\n        (options.isNativeTag && !options.isNativeTag(tag))) {\n        return true;\n    }\n    // at this point the tag should be a native tag, but check for potential \"is\"\n    // casting\n    for (let i = 0; i < props.length; i++) {\n        const p = props[i];\n        if (p.type === 6 /* NodeTypes.ATTRIBUTE */) {\n            if (p.name === 'is' && p.value) {\n                if (p.value.content.startsWith('vue:')) {\n                    return true;\n                }\n                else if (checkCompatEnabled(\"COMPILER_IS_ON_ELEMENT\" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */, context, p.loc)) {\n                    return true;\n                }\n            }\n        }\n        else {\n            // directive\n            // v-is (TODO Deprecate)\n            if (p.name === 'is') {\n                return true;\n            }\n            else if (\n            // :is on plain element - only treat as component in compat mode\n            p.name === 'bind' &&\n                isStaticArgOf(p.arg, 'is') &&\n                true &&\n                checkCompatEnabled(\"COMPILER_IS_ON_ELEMENT\" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */, context, p.loc)) {\n                return true;\n            }\n        }\n    }\n}\nfunction parseAttributes(context, type) {\n    const props = [];\n    const attributeNames = new Set();\n    while (context.source.length > 0 &&\n        !startsWith(context.source, '>') &&\n        !startsWith(context.source, '/>')) {\n        if (startsWith(context.source, '/')) {\n            emitError(context, 22 /* ErrorCodes.UNEXPECTED_SOLIDUS_IN_TAG */);\n            advanceBy(context, 1);\n            advanceSpaces(context);\n            continue;\n        }\n        if (type === 1 /* TagType.End */) {\n            emitError(context, 3 /* ErrorCodes.END_TAG_WITH_ATTRIBUTES */);\n        }\n        const attr = parseAttribute(context, attributeNames);\n        // Trim whitespace between class\n        // https://github.com/vuejs/core/issues/4251\n        if (attr.type === 6 /* NodeTypes.ATTRIBUTE */ &&\n            attr.value &&\n            attr.name === 'class') {\n            attr.value.content = attr.value.content.replace(/\\s+/g, ' ').trim();\n        }\n        if (type === 0 /* TagType.Start */) {\n            props.push(attr);\n        }\n        if (/^[^\\t\\r\\n\\f />]/.test(context.source)) {\n            emitError(context, 15 /* ErrorCodes.MISSING_WHITESPACE_BETWEEN_ATTRIBUTES */);\n        }\n        advanceSpaces(context);\n    }\n    return props;\n}\nfunction parseAttribute(context, nameSet) {\n    // Name.\n    const start = getCursor(context);\n    const match = /^[^\\t\\r\\n\\f />][^\\t\\r\\n\\f />=]*/.exec(context.source);\n    const name = match[0];\n    if (nameSet.has(name)) {\n        emitError(context, 2 /* ErrorCodes.DUPLICATE_ATTRIBUTE */);\n    }\n    nameSet.add(name);\n    if (name[0] === '=') {\n        emitError(context, 19 /* ErrorCodes.UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME */);\n    }\n    {\n        const pattern = /[\"'<]/g;\n        let m;\n        while ((m = pattern.exec(name))) {\n            emitError(context, 17 /* ErrorCodes.UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME */, m.index);\n        }\n    }\n    advanceBy(context, name.length);\n    // Value\n    let value = undefined;\n    if (/^[\\t\\r\\n\\f ]*=/.test(context.source)) {\n        advanceSpaces(context);\n        advanceBy(context, 1);\n        advanceSpaces(context);\n        value = parseAttributeValue(context);\n        if (!value) {\n            emitError(context, 13 /* ErrorCodes.MISSING_ATTRIBUTE_VALUE */);\n        }\n    }\n    const loc = getSelection(context, start);\n    if (!context.inVPre && /^(v-[A-Za-z0-9-]|:|\\.|@|#)/.test(name)) {\n        const match = /(?:^v-([a-z0-9-]+))?(?:(?::|^\\.|^@|^#)(\\[[^\\]]+\\]|[^\\.]+))?(.+)?$/i.exec(name);\n        let isPropShorthand = startsWith(name, '.');\n        let dirName = match[1] ||\n            (isPropShorthand || startsWith(name, ':')\n                ? 'bind'\n                : startsWith(name, '@')\n                    ? 'on'\n                    : 'slot');\n        let arg;\n        if (match[2]) {\n            const isSlot = dirName === 'slot';\n            const startOffset = name.lastIndexOf(match[2]);\n            const loc = getSelection(context, getNewPosition(context, start, startOffset), getNewPosition(context, start, startOffset + match[2].length + ((isSlot && match[3]) || '').length));\n            let content = match[2];\n            let isStatic = true;\n            if (content.startsWith('[')) {\n                isStatic = false;\n                if (!content.endsWith(']')) {\n                    emitError(context, 27 /* ErrorCodes.X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END */);\n                    content = content.slice(1);\n                }\n                else {\n                    content = content.slice(1, content.length - 1);\n                }\n            }\n            else if (isSlot) {\n                // #1241 special case for v-slot: vuetify relies extensively on slot\n                // names containing dots. v-slot doesn't have any modifiers and Vue 2.x\n                // supports such usage so we are keeping it consistent with 2.x.\n                content += match[3] || '';\n            }\n            arg = {\n                type: 4 /* NodeTypes.SIMPLE_EXPRESSION */,\n                content,\n                isStatic,\n                constType: isStatic\n                    ? 3 /* ConstantTypes.CAN_STRINGIFY */\n                    : 0 /* ConstantTypes.NOT_CONSTANT */,\n                loc\n            };\n        }\n        if (value && value.isQuoted) {\n            const valueLoc = value.loc;\n            valueLoc.start.offset++;\n            valueLoc.start.column++;\n            valueLoc.end = advancePositionWithClone(valueLoc.start, value.content);\n            valueLoc.source = valueLoc.source.slice(1, -1);\n        }\n        const modifiers = match[3] ? match[3].slice(1).split('.') : [];\n        if (isPropShorthand)\n            modifiers.push('prop');\n        // 2.x compat v-bind:foo.sync -> v-model:foo\n        if (dirName === 'bind' && arg) {\n            if (modifiers.includes('sync') &&\n                checkCompatEnabled(\"COMPILER_V_BIND_SYNC\" /* CompilerDeprecationTypes.COMPILER_V_BIND_SYNC */, context, loc, arg.loc.source)) {\n                dirName = 'model';\n                modifiers.splice(modifiers.indexOf('sync'), 1);\n            }\n            if ((process.env.NODE_ENV !== 'production') && modifiers.includes('prop')) {\n                checkCompatEnabled(\"COMPILER_V_BIND_PROP\" /* CompilerDeprecationTypes.COMPILER_V_BIND_PROP */, context, loc);\n            }\n        }\n        return {\n            type: 7 /* NodeTypes.DIRECTIVE */,\n            name: dirName,\n            exp: value && {\n                type: 4 /* NodeTypes.SIMPLE_EXPRESSION */,\n                content: value.content,\n                isStatic: false,\n                // Treat as non-constant by default. This can be potentially set to\n                // other values by `transformExpression` to make it eligible for hoisting.\n                constType: 0 /* ConstantTypes.NOT_CONSTANT */,\n                loc: value.loc\n            },\n            arg,\n            modifiers,\n            loc\n        };\n    }\n    // missing directive name or illegal directive name\n    if (!context.inVPre && startsWith(name, 'v-')) {\n        emitError(context, 26 /* ErrorCodes.X_MISSING_DIRECTIVE_NAME */);\n    }\n    return {\n        type: 6 /* NodeTypes.ATTRIBUTE */,\n        name,\n        value: value && {\n            type: 2 /* NodeTypes.TEXT */,\n            content: value.content,\n            loc: value.loc\n        },\n        loc\n    };\n}\nfunction parseAttributeValue(context) {\n    const start = getCursor(context);\n    let content;\n    const quote = context.source[0];\n    const isQuoted = quote === `\"` || quote === `'`;\n    if (isQuoted) {\n        // Quoted value.\n        advanceBy(context, 1);\n        const endIndex = context.source.indexOf(quote);\n        if (endIndex === -1) {\n            content = parseTextData(context, context.source.length, 4 /* TextModes.ATTRIBUTE_VALUE */);\n        }\n        else {\n            content = parseTextData(context, endIndex, 4 /* TextModes.ATTRIBUTE_VALUE */);\n            advanceBy(context, 1);\n        }\n    }\n    else {\n        // Unquoted\n        const match = /^[^\\t\\r\\n\\f >]+/.exec(context.source);\n        if (!match) {\n            return undefined;\n        }\n        const unexpectedChars = /[\"'<=`]/g;\n        let m;\n        while ((m = unexpectedChars.exec(match[0]))) {\n            emitError(context, 18 /* ErrorCodes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE */, m.index);\n        }\n        content = parseTextData(context, match[0].length, 4 /* TextModes.ATTRIBUTE_VALUE */);\n    }\n    return { content, isQuoted, loc: getSelection(context, start) };\n}\nfunction parseInterpolation(context, mode) {\n    const [open, close] = context.options.delimiters;\n    const closeIndex = context.source.indexOf(close, open.length);\n    if (closeIndex === -1) {\n        emitError(context, 25 /* ErrorCodes.X_MISSING_INTERPOLATION_END */);\n        return undefined;\n    }\n    const start = getCursor(context);\n    advanceBy(context, open.length);\n    const innerStart = getCursor(context);\n    const innerEnd = getCursor(context);\n    const rawContentLength = closeIndex - open.length;\n    const rawContent = context.source.slice(0, rawContentLength);\n    const preTrimContent = parseTextData(context, rawContentLength, mode);\n    const content = preTrimContent.trim();\n    const startOffset = preTrimContent.indexOf(content);\n    if (startOffset > 0) {\n        advancePositionWithMutation(innerStart, rawContent, startOffset);\n    }\n    const endOffset = rawContentLength - (preTrimContent.length - content.length - startOffset);\n    advancePositionWithMutation(innerEnd, rawContent, endOffset);\n    advanceBy(context, close.length);\n    return {\n        type: 5 /* NodeTypes.INTERPOLATION */,\n        content: {\n            type: 4 /* NodeTypes.SIMPLE_EXPRESSION */,\n            isStatic: false,\n            // Set `isConstant` to false by default and will decide in transformExpression\n            constType: 0 /* ConstantTypes.NOT_CONSTANT */,\n            content,\n            loc: getSelection(context, innerStart, innerEnd)\n        },\n        loc: getSelection(context, start)\n    };\n}\nfunction parseText(context, mode) {\n    const endTokens = mode === 3 /* TextModes.CDATA */ ? [']]>'] : ['<', context.options.delimiters[0]];\n    let endIndex = context.source.length;\n    for (let i = 0; i < endTokens.length; i++) {\n        const index = context.source.indexOf(endTokens[i], 1);\n        if (index !== -1 && endIndex > index) {\n            endIndex = index;\n        }\n    }\n    const start = getCursor(context);\n    const content = parseTextData(context, endIndex, mode);\n    return {\n        type: 2 /* NodeTypes.TEXT */,\n        content,\n        loc: getSelection(context, start)\n    };\n}\n/**\n * Get text data with a given length from the current location.\n * This translates HTML entities in the text data.\n */\nfunction parseTextData(context, length, mode) {\n    const rawText = context.source.slice(0, length);\n    advanceBy(context, length);\n    if (mode === 2 /* TextModes.RAWTEXT */ ||\n        mode === 3 /* TextModes.CDATA */ ||\n        !rawText.includes('&')) {\n        return rawText;\n    }\n    else {\n        // DATA or RCDATA containing \"&\"\". Entity decoding required.\n        return context.options.decodeEntities(rawText, mode === 4 /* TextModes.ATTRIBUTE_VALUE */);\n    }\n}\nfunction getCursor(context) {\n    const { column, line, offset } = context;\n    return { column, line, offset };\n}\nfunction getSelection(context, start, end) {\n    end = end || getCursor(context);\n    return {\n        start,\n        end,\n        source: context.originalSource.slice(start.offset, end.offset)\n    };\n}\nfunction last(xs) {\n    return xs[xs.length - 1];\n}\nfunction startsWith(source, searchString) {\n    return source.startsWith(searchString);\n}\nfunction advanceBy(context, numberOfCharacters) {\n    const { source } = context;\n    advancePositionWithMutation(context, source, numberOfCharacters);\n    context.source = source.slice(numberOfCharacters);\n}\nfunction advanceSpaces(context) {\n    const match = /^[\\t\\r\\n\\f ]+/.exec(context.source);\n    if (match) {\n        advanceBy(context, match[0].length);\n    }\n}\nfunction getNewPosition(context, start, numberOfCharacters) {\n    return advancePositionWithClone(start, context.originalSource.slice(start.offset, numberOfCharacters), numberOfCharacters);\n}\nfunction emitError(context, code, offset, loc = getCursor(context)) {\n    if (offset) {\n        loc.offset += offset;\n        loc.column += offset;\n    }\n    context.options.onError(createCompilerError(code, {\n        start: loc,\n        end: loc,\n        source: ''\n    }));\n}\nfunction isEnd(context, mode, ancestors) {\n    const s = context.source;\n    switch (mode) {\n        case 0 /* TextModes.DATA */:\n            if (startsWith(s, '</')) {\n                // TODO: probably bad performance\n                for (let i = ancestors.length - 1; i >= 0; --i) {\n                    if (startsWithEndTagOpen(s, ancestors[i].tag)) {\n                        return true;\n                    }\n                }\n            }\n            break;\n        case 1 /* TextModes.RCDATA */:\n        case 2 /* TextModes.RAWTEXT */: {\n            const parent = last(ancestors);\n            if (parent && startsWithEndTagOpen(s, parent.tag)) {\n                return true;\n            }\n            break;\n        }\n        case 3 /* TextModes.CDATA */:\n            if (startsWith(s, ']]>')) {\n                return true;\n            }\n            break;\n    }\n    return !s;\n}\nfunction startsWithEndTagOpen(source, tag) {\n    return (startsWith(source, '</') &&\n        source.slice(2, 2 + tag.length).toLowerCase() === tag.toLowerCase() &&\n        /[\\t\\r\\n\\f />]/.test(source[2 + tag.length] || '>'));\n}\n\nfunction hoistStatic(root, context) {\n    walk(root, context, \n    // Root node is unfortunately non-hoistable due to potential parent\n    // fallthrough attributes.\n    isSingleElementRoot(root, root.children[0]));\n}\nfunction isSingleElementRoot(root, child) {\n    const { children } = root;\n    return (children.length === 1 &&\n        child.type === 1 /* NodeTypes.ELEMENT */ &&\n        !isSlotOutlet(child));\n}\nfunction walk(node, context, doNotHoistNode = false) {\n    const { children } = node;\n    const originalCount = children.length;\n    let hoistedCount = 0;\n    for (let i = 0; i < children.length; i++) {\n        const child = children[i];\n        // only plain elements & text calls are eligible for hoisting.\n        if (child.type === 1 /* NodeTypes.ELEMENT */ &&\n            child.tagType === 0 /* ElementTypes.ELEMENT */) {\n            const constantType = doNotHoistNode\n                ? 0 /* ConstantTypes.NOT_CONSTANT */\n                : getConstantType(child, context);\n            if (constantType > 0 /* ConstantTypes.NOT_CONSTANT */) {\n                if (constantType >= 2 /* ConstantTypes.CAN_HOIST */) {\n                    child.codegenNode.patchFlag =\n                        -1 /* PatchFlags.HOISTED */ + ((process.env.NODE_ENV !== 'production') ? ` /* HOISTED */` : ``);\n                    child.codegenNode = context.hoist(child.codegenNode);\n                    hoistedCount++;\n                    continue;\n                }\n            }\n            else {\n                // node may contain dynamic children, but its props may be eligible for\n                // hoisting.\n                const codegenNode = child.codegenNode;\n                if (codegenNode.type === 13 /* NodeTypes.VNODE_CALL */) {\n                    const flag = getPatchFlag(codegenNode);\n                    if ((!flag ||\n                        flag === 512 /* PatchFlags.NEED_PATCH */ ||\n                        flag === 1 /* PatchFlags.TEXT */) &&\n                        getGeneratedPropsConstantType(child, context) >=\n                            2 /* ConstantTypes.CAN_HOIST */) {\n                        const props = getNodeProps(child);\n                        if (props) {\n                            codegenNode.props = context.hoist(props);\n                        }\n                    }\n                    if (codegenNode.dynamicProps) {\n                        codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);\n                    }\n                }\n            }\n        }\n        // walk further\n        if (child.type === 1 /* NodeTypes.ELEMENT */) {\n            const isComponent = child.tagType === 1 /* ElementTypes.COMPONENT */;\n            if (isComponent) {\n                context.scopes.vSlot++;\n            }\n            walk(child, context);\n            if (isComponent) {\n                context.scopes.vSlot--;\n            }\n        }\n        else if (child.type === 11 /* NodeTypes.FOR */) {\n            // Do not hoist v-for single child because it has to be a block\n            walk(child, context, child.children.length === 1);\n        }\n        else if (child.type === 9 /* NodeTypes.IF */) {\n            for (let i = 0; i < child.branches.length; i++) {\n                // Do not hoist v-if single child because it has to be a block\n                walk(child.branches[i], context, child.branches[i].children.length === 1);\n            }\n        }\n    }\n    if (hoistedCount && context.transformHoist) {\n        context.transformHoist(children, context, node);\n    }\n    // all children were hoisted - the entire children array is hoistable.\n    if (hoistedCount &&\n        hoistedCount === originalCount &&\n        node.type === 1 /* NodeTypes.ELEMENT */ &&\n        node.tagType === 0 /* ElementTypes.ELEMENT */ &&\n        node.codegenNode &&\n        node.codegenNode.type === 13 /* NodeTypes.VNODE_CALL */ &&\n        isArray(node.codegenNode.children)) {\n        node.codegenNode.children = context.hoist(createArrayExpression(node.codegenNode.children));\n    }\n}\nfunction getConstantType(node, context) {\n    const { constantCache } = context;\n    switch (node.type) {\n        case 1 /* NodeTypes.ELEMENT */:\n            if (node.tagType !== 0 /* ElementTypes.ELEMENT */) {\n                return 0 /* ConstantTypes.NOT_CONSTANT */;\n            }\n            const cached = constantCache.get(node);\n            if (cached !== undefined) {\n                return cached;\n            }\n            const codegenNode = node.codegenNode;\n            if (codegenNode.type !== 13 /* NodeTypes.VNODE_CALL */) {\n                return 0 /* ConstantTypes.NOT_CONSTANT */;\n            }\n            if (codegenNode.isBlock &&\n                node.tag !== 'svg' &&\n                node.tag !== 'foreignObject') {\n                return 0 /* ConstantTypes.NOT_CONSTANT */;\n            }\n            const flag = getPatchFlag(codegenNode);\n            if (!flag) {\n                let returnType = 3 /* ConstantTypes.CAN_STRINGIFY */;\n                // Element itself has no patch flag. However we still need to check:\n                // 1. Even for a node with no patch flag, it is possible for it to contain\n                // non-hoistable expressions that refers to scope variables, e.g. compiler\n                // injected keys or cached event handlers. Therefore we need to always\n                // check the codegenNode's props to be sure.\n                const generatedPropsType = getGeneratedPropsConstantType(node, context);\n                if (generatedPropsType === 0 /* ConstantTypes.NOT_CONSTANT */) {\n                    constantCache.set(node, 0 /* ConstantTypes.NOT_CONSTANT */);\n                    return 0 /* ConstantTypes.NOT_CONSTANT */;\n                }\n                if (generatedPropsType < returnType) {\n                    returnType = generatedPropsType;\n                }\n                // 2. its children.\n                for (let i = 0; i < node.children.length; i++) {\n                    const childType = getConstantType(node.children[i], context);\n                    if (childType === 0 /* ConstantTypes.NOT_CONSTANT */) {\n                        constantCache.set(node, 0 /* ConstantTypes.NOT_CONSTANT */);\n                        return 0 /* ConstantTypes.NOT_CONSTANT */;\n                    }\n                    if (childType < returnType) {\n                        returnType = childType;\n                    }\n                }\n                // 3. if the type is not already CAN_SKIP_PATCH which is the lowest non-0\n                // type, check if any of the props can cause the type to be lowered\n                // we can skip can_patch because it's guaranteed by the absence of a\n                // patchFlag.\n                if (returnType > 1 /* ConstantTypes.CAN_SKIP_PATCH */) {\n                    for (let i = 0; i < node.props.length; i++) {\n                        const p = node.props[i];\n                        if (p.type === 7 /* NodeTypes.DIRECTIVE */ && p.name === 'bind' && p.exp) {\n                            const expType = getConstantType(p.exp, context);\n                            if (expType === 0 /* ConstantTypes.NOT_CONSTANT */) {\n                                constantCache.set(node, 0 /* ConstantTypes.NOT_CONSTANT */);\n                                return 0 /* ConstantTypes.NOT_CONSTANT */;\n                            }\n                            if (expType < returnType) {\n                                returnType = expType;\n                            }\n                        }\n                    }\n                }\n                // only svg/foreignObject could be block here, however if they are\n                // static then they don't need to be blocks since there will be no\n                // nested updates.\n                if (codegenNode.isBlock) {\n                    // except set custom directives.\n                    for (let i = 0; i < node.props.length; i++) {\n                        const p = node.props[i];\n                        if (p.type === 7 /* NodeTypes.DIRECTIVE */) {\n                            constantCache.set(node, 0 /* ConstantTypes.NOT_CONSTANT */);\n                            return 0 /* ConstantTypes.NOT_CONSTANT */;\n                        }\n                    }\n                    context.removeHelper(OPEN_BLOCK);\n                    context.removeHelper(getVNodeBlockHelper(context.inSSR, codegenNode.isComponent));\n                    codegenNode.isBlock = false;\n                    context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));\n                }\n                constantCache.set(node, returnType);\n                return returnType;\n            }\n            else {\n                constantCache.set(node, 0 /* ConstantTypes.NOT_CONSTANT */);\n                return 0 /* ConstantTypes.NOT_CONSTANT */;\n            }\n        case 2 /* NodeTypes.TEXT */:\n        case 3 /* NodeTypes.COMMENT */:\n            return 3 /* ConstantTypes.CAN_STRINGIFY */;\n        case 9 /* NodeTypes.IF */:\n        case 11 /* NodeTypes.FOR */:\n        case 10 /* NodeTypes.IF_BRANCH */:\n            return 0 /* ConstantTypes.NOT_CONSTANT */;\n        case 5 /* NodeTypes.INTERPOLATION */:\n        case 12 /* NodeTypes.TEXT_CALL */:\n            return getConstantType(node.content, context);\n        case 4 /* NodeTypes.SIMPLE_EXPRESSION */:\n            return node.constType;\n        case 8 /* NodeTypes.COMPOUND_EXPRESSION */:\n            let returnType = 3 /* ConstantTypes.CAN_STRINGIFY */;\n            for (let i = 0; i < node.children.length; i++) {\n                const child = node.children[i];\n                if (isString(child) || isSymbol(child)) {\n                    continue;\n                }\n                const childType = getConstantType(child, context);\n                if (childType === 0 /* ConstantTypes.NOT_CONSTANT */) {\n                    return 0 /* ConstantTypes.NOT_CONSTANT */;\n                }\n                else if (childType < returnType) {\n                    returnType = childType;\n                }\n            }\n            return returnType;\n        default:\n            if ((process.env.NODE_ENV !== 'production')) ;\n            return 0 /* ConstantTypes.NOT_CONSTANT */;\n    }\n}\nconst allowHoistedHelperSet = new Set([\n    NORMALIZE_CLASS,\n    NORMALIZE_STYLE,\n    NORMALIZE_PROPS,\n    GUARD_REACTIVE_PROPS\n]);\nfunction getConstantTypeOfHelperCall(value, context) {\n    if (value.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */ &&\n        !isString(value.callee) &&\n        allowHoistedHelperSet.has(value.callee)) {\n        const arg = value.arguments[0];\n        if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n            return getConstantType(arg, context);\n        }\n        else if (arg.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) {\n            // in the case of nested helper call, e.g. `normalizeProps(guardReactiveProps(exp))`\n            return getConstantTypeOfHelperCall(arg, context);\n        }\n    }\n    return 0 /* ConstantTypes.NOT_CONSTANT */;\n}\nfunction getGeneratedPropsConstantType(node, context) {\n    let returnType = 3 /* ConstantTypes.CAN_STRINGIFY */;\n    const props = getNodeProps(node);\n    if (props && props.type === 15 /* NodeTypes.JS_OBJECT_EXPRESSION */) {\n        const { properties } = props;\n        for (let i = 0; i < properties.length; i++) {\n            const { key, value } = properties[i];\n            const keyType = getConstantType(key, context);\n            if (keyType === 0 /* ConstantTypes.NOT_CONSTANT */) {\n                return keyType;\n            }\n            if (keyType < returnType) {\n                returnType = keyType;\n            }\n            let valueType;\n            if (value.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n                valueType = getConstantType(value, context);\n            }\n            else if (value.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) {\n                // some helper calls can be hoisted,\n                // such as the `normalizeProps` generated by the compiler for pre-normalize class,\n                // in this case we need to respect the ConstantType of the helper's arguments\n                valueType = getConstantTypeOfHelperCall(value, context);\n            }\n            else {\n                valueType = 0 /* ConstantTypes.NOT_CONSTANT */;\n            }\n            if (valueType === 0 /* ConstantTypes.NOT_CONSTANT */) {\n                return valueType;\n            }\n            if (valueType < returnType) {\n                returnType = valueType;\n            }\n        }\n    }\n    return returnType;\n}\nfunction getNodeProps(node) {\n    const codegenNode = node.codegenNode;\n    if (codegenNode.type === 13 /* NodeTypes.VNODE_CALL */) {\n        return codegenNode.props;\n    }\n}\nfunction getPatchFlag(node) {\n    const flag = node.patchFlag;\n    return flag ? parseInt(flag, 10) : undefined;\n}\n\nfunction createTransformContext(root, { filename = '', prefixIdentifiers = false, hoistStatic = false, cacheHandlers = false, nodeTransforms = [], directiveTransforms = {}, transformHoist = null, isBuiltInComponent = NOOP, isCustomElement = NOOP, expressionPlugins = [], scopeId = null, slotted = true, ssr = false, inSSR = false, ssrCssVars = ``, bindingMetadata = EMPTY_OBJ, inline = false, isTS = false, onError = defaultOnError, onWarn = defaultOnWarn, compatConfig }) {\n    const nameMatch = filename.replace(/\\?.*$/, '').match(/([^/\\\\]+)\\.\\w+$/);\n    const context = {\n        // options\n        selfName: nameMatch && capitalize(camelize$1(nameMatch[1])),\n        prefixIdentifiers,\n        hoistStatic,\n        cacheHandlers,\n        nodeTransforms,\n        directiveTransforms,\n        transformHoist,\n        isBuiltInComponent,\n        isCustomElement,\n        expressionPlugins,\n        scopeId,\n        slotted,\n        ssr,\n        inSSR,\n        ssrCssVars,\n        bindingMetadata,\n        inline,\n        isTS,\n        onError,\n        onWarn,\n        compatConfig,\n        // state\n        root,\n        helpers: new Map(),\n        components: new Set(),\n        directives: new Set(),\n        hoists: [],\n        imports: [],\n        constantCache: new Map(),\n        temps: 0,\n        cached: 0,\n        identifiers: Object.create(null),\n        scopes: {\n            vFor: 0,\n            vSlot: 0,\n            vPre: 0,\n            vOnce: 0\n        },\n        parent: null,\n        currentNode: root,\n        childIndex: 0,\n        inVOnce: false,\n        // methods\n        helper(name) {\n            const count = context.helpers.get(name) || 0;\n            context.helpers.set(name, count + 1);\n            return name;\n        },\n        removeHelper(name) {\n            const count = context.helpers.get(name);\n            if (count) {\n                const currentCount = count - 1;\n                if (!currentCount) {\n                    context.helpers.delete(name);\n                }\n                else {\n                    context.helpers.set(name, currentCount);\n                }\n            }\n        },\n        helperString(name) {\n            return `_${helperNameMap[context.helper(name)]}`;\n        },\n        replaceNode(node) {\n            /* istanbul ignore if */\n            if ((process.env.NODE_ENV !== 'production')) {\n                if (!context.currentNode) {\n                    throw new Error(`Node being replaced is already removed.`);\n                }\n                if (!context.parent) {\n                    throw new Error(`Cannot replace root node.`);\n                }\n            }\n            context.parent.children[context.childIndex] = context.currentNode = node;\n        },\n        removeNode(node) {\n            if ((process.env.NODE_ENV !== 'production') && !context.parent) {\n                throw new Error(`Cannot remove root node.`);\n            }\n            const list = context.parent.children;\n            const removalIndex = node\n                ? list.indexOf(node)\n                : context.currentNode\n                    ? context.childIndex\n                    : -1;\n            /* istanbul ignore if */\n            if ((process.env.NODE_ENV !== 'production') && removalIndex < 0) {\n                throw new Error(`node being removed is not a child of current parent`);\n            }\n            if (!node || node === context.currentNode) {\n                // current node removed\n                context.currentNode = null;\n                context.onNodeRemoved();\n            }\n            else {\n                // sibling node removed\n                if (context.childIndex > removalIndex) {\n                    context.childIndex--;\n                    context.onNodeRemoved();\n                }\n            }\n            context.parent.children.splice(removalIndex, 1);\n        },\n        onNodeRemoved: () => { },\n        addIdentifiers(exp) {\n        },\n        removeIdentifiers(exp) {\n        },\n        hoist(exp) {\n            if (isString(exp))\n                exp = createSimpleExpression(exp);\n            context.hoists.push(exp);\n            const identifier = createSimpleExpression(`_hoisted_${context.hoists.length}`, false, exp.loc, 2 /* ConstantTypes.CAN_HOIST */);\n            identifier.hoisted = exp;\n            return identifier;\n        },\n        cache(exp, isVNode = false) {\n            return createCacheExpression(context.cached++, exp, isVNode);\n        }\n    };\n    {\n        context.filters = new Set();\n    }\n    return context;\n}\nfunction transform(root, options) {\n    const context = createTransformContext(root, options);\n    traverseNode(root, context);\n    if (options.hoistStatic) {\n        hoistStatic(root, context);\n    }\n    if (!options.ssr) {\n        createRootCodegen(root, context);\n    }\n    // finalize meta information\n    root.helpers = [...context.helpers.keys()];\n    root.components = [...context.components];\n    root.directives = [...context.directives];\n    root.imports = context.imports;\n    root.hoists = context.hoists;\n    root.temps = context.temps;\n    root.cached = context.cached;\n    {\n        root.filters = [...context.filters];\n    }\n}\nfunction createRootCodegen(root, context) {\n    const { helper } = context;\n    const { children } = root;\n    if (children.length === 1) {\n        const child = children[0];\n        // if the single child is an element, turn it into a block.\n        if (isSingleElementRoot(root, child) && child.codegenNode) {\n            // single element root is never hoisted so codegenNode will never be\n            // SimpleExpressionNode\n            const codegenNode = child.codegenNode;\n            if (codegenNode.type === 13 /* NodeTypes.VNODE_CALL */) {\n                makeBlock(codegenNode, context);\n            }\n            root.codegenNode = codegenNode;\n        }\n        else {\n            // - single <slot/>, IfNode, ForNode: already blocks.\n            // - single text node: always patched.\n            // root codegen falls through via genNode()\n            root.codegenNode = child;\n        }\n    }\n    else if (children.length > 1) {\n        // root has multiple nodes - return a fragment block.\n        let patchFlag = 64 /* PatchFlags.STABLE_FRAGMENT */;\n        let patchFlagText = PatchFlagNames[64 /* PatchFlags.STABLE_FRAGMENT */];\n        // check if the fragment actually contains a single valid child with\n        // the rest being comments\n        if ((process.env.NODE_ENV !== 'production') &&\n            children.filter(c => c.type !== 3 /* NodeTypes.COMMENT */).length === 1) {\n            patchFlag |= 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */;\n            patchFlagText += `, ${PatchFlagNames[2048 /* PatchFlags.DEV_ROOT_FRAGMENT */]}`;\n        }\n        root.codegenNode = createVNodeCall(context, helper(FRAGMENT), undefined, root.children, patchFlag + ((process.env.NODE_ENV !== 'production') ? ` /* ${patchFlagText} */` : ``), undefined, undefined, true, undefined, false /* isComponent */);\n    }\n    else ;\n}\nfunction traverseChildren(parent, context) {\n    let i = 0;\n    const nodeRemoved = () => {\n        i--;\n    };\n    for (; i < parent.children.length; i++) {\n        const child = parent.children[i];\n        if (isString(child))\n            continue;\n        context.parent = parent;\n        context.childIndex = i;\n        context.onNodeRemoved = nodeRemoved;\n        traverseNode(child, context);\n    }\n}\nfunction traverseNode(node, context) {\n    context.currentNode = node;\n    // apply transform plugins\n    const { nodeTransforms } = context;\n    const exitFns = [];\n    for (let i = 0; i < nodeTransforms.length; i++) {\n        const onExit = nodeTransforms[i](node, context);\n        if (onExit) {\n            if (isArray(onExit)) {\n                exitFns.push(...onExit);\n            }\n            else {\n                exitFns.push(onExit);\n            }\n        }\n        if (!context.currentNode) {\n            // node was removed\n            return;\n        }\n        else {\n            // node may have been replaced\n            node = context.currentNode;\n        }\n    }\n    switch (node.type) {\n        case 3 /* NodeTypes.COMMENT */:\n            if (!context.ssr) {\n                // inject import for the Comment symbol, which is needed for creating\n                // comment nodes with `createVNode`\n                context.helper(CREATE_COMMENT);\n            }\n            break;\n        case 5 /* NodeTypes.INTERPOLATION */:\n            // no need to traverse, but we need to inject toString helper\n            if (!context.ssr) {\n                context.helper(TO_DISPLAY_STRING);\n            }\n            break;\n        // for container types, further traverse downwards\n        case 9 /* NodeTypes.IF */:\n            for (let i = 0; i < node.branches.length; i++) {\n                traverseNode(node.branches[i], context);\n            }\n            break;\n        case 10 /* NodeTypes.IF_BRANCH */:\n        case 11 /* NodeTypes.FOR */:\n        case 1 /* NodeTypes.ELEMENT */:\n        case 0 /* NodeTypes.ROOT */:\n            traverseChildren(node, context);\n            break;\n    }\n    // exit transforms\n    context.currentNode = node;\n    let i = exitFns.length;\n    while (i--) {\n        exitFns[i]();\n    }\n}\nfunction createStructuralDirectiveTransform(name, fn) {\n    const matches = isString(name)\n        ? (n) => n === name\n        : (n) => name.test(n);\n    return (node, context) => {\n        if (node.type === 1 /* NodeTypes.ELEMENT */) {\n            const { props } = node;\n            // structural directive transforms are not concerned with slots\n            // as they are handled separately in vSlot.ts\n            if (node.tagType === 3 /* ElementTypes.TEMPLATE */ && props.some(isVSlot)) {\n                return;\n            }\n            const exitFns = [];\n            for (let i = 0; i < props.length; i++) {\n                const prop = props[i];\n                if (prop.type === 7 /* NodeTypes.DIRECTIVE */ && matches(prop.name)) {\n                    // structural directives are removed to avoid infinite recursion\n                    // also we remove them *before* applying so that it can further\n                    // traverse itself in case it moves the node around\n                    props.splice(i, 1);\n                    i--;\n                    const onExit = fn(node, prop, context);\n                    if (onExit)\n                        exitFns.push(onExit);\n                }\n            }\n            return exitFns;\n        }\n    };\n}\n\nconst PURE_ANNOTATION = `/*#__PURE__*/`;\nconst aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;\nfunction 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 }) {\n    const context = {\n        mode,\n        prefixIdentifiers,\n        sourceMap,\n        filename,\n        scopeId,\n        optimizeImports,\n        runtimeGlobalName,\n        runtimeModuleName,\n        ssrRuntimeModuleName,\n        ssr,\n        isTS,\n        inSSR,\n        source: ast.loc.source,\n        code: ``,\n        column: 1,\n        line: 1,\n        offset: 0,\n        indentLevel: 0,\n        pure: false,\n        map: undefined,\n        helper(key) {\n            return `_${helperNameMap[key]}`;\n        },\n        push(code, node) {\n            context.code += code;\n        },\n        indent() {\n            newline(++context.indentLevel);\n        },\n        deindent(withoutNewLine = false) {\n            if (withoutNewLine) {\n                --context.indentLevel;\n            }\n            else {\n                newline(--context.indentLevel);\n            }\n        },\n        newline() {\n            newline(context.indentLevel);\n        }\n    };\n    function newline(n) {\n        context.push('\\n' + `  `.repeat(n));\n    }\n    return context;\n}\nfunction generate(ast, options = {}) {\n    const context = createCodegenContext(ast, options);\n    if (options.onContextCreated)\n        options.onContextCreated(context);\n    const { mode, push, prefixIdentifiers, indent, deindent, newline, scopeId, ssr } = context;\n    const hasHelpers = ast.helpers.length > 0;\n    const useWithBlock = !prefixIdentifiers && mode !== 'module';\n    // preambles\n    // in setup() inline mode, the preamble is generated in a sub context\n    // and returned separately.\n    const preambleContext = context;\n    {\n        genFunctionPreamble(ast, preambleContext);\n    }\n    // enter render function\n    const functionName = ssr ? `ssrRender` : `render`;\n    const args = ssr ? ['_ctx', '_push', '_parent', '_attrs'] : ['_ctx', '_cache'];\n    const signature = args.join(', ');\n    {\n        push(`function ${functionName}(${signature}) {`);\n    }\n    indent();\n    if (useWithBlock) {\n        push(`with (_ctx) {`);\n        indent();\n        // function mode const declarations should be inside with block\n        // also they should be renamed to avoid collision with user properties\n        if (hasHelpers) {\n            push(`const { ${ast.helpers.map(aliasHelper).join(', ')} } = _Vue`);\n            push(`\\n`);\n            newline();\n        }\n    }\n    // generate asset resolution statements\n    if (ast.components.length) {\n        genAssets(ast.components, 'component', context);\n        if (ast.directives.length || ast.temps > 0) {\n            newline();\n        }\n    }\n    if (ast.directives.length) {\n        genAssets(ast.directives, 'directive', context);\n        if (ast.temps > 0) {\n            newline();\n        }\n    }\n    if (ast.filters && ast.filters.length) {\n        newline();\n        genAssets(ast.filters, 'filter', context);\n        newline();\n    }\n    if (ast.temps > 0) {\n        push(`let `);\n        for (let i = 0; i < ast.temps; i++) {\n            push(`${i > 0 ? `, ` : ``}_temp${i}`);\n        }\n    }\n    if (ast.components.length || ast.directives.length || ast.temps) {\n        push(`\\n`);\n        newline();\n    }\n    // generate the VNode tree expression\n    if (!ssr) {\n        push(`return `);\n    }\n    if (ast.codegenNode) {\n        genNode(ast.codegenNode, context);\n    }\n    else {\n        push(`null`);\n    }\n    if (useWithBlock) {\n        deindent();\n        push(`}`);\n    }\n    deindent();\n    push(`}`);\n    return {\n        ast,\n        code: context.code,\n        preamble: ``,\n        // SourceMapGenerator does have toJSON() method but it's not in the types\n        map: context.map ? context.map.toJSON() : undefined\n    };\n}\nfunction genFunctionPreamble(ast, context) {\n    const { ssr, prefixIdentifiers, push, newline, runtimeModuleName, runtimeGlobalName, ssrRuntimeModuleName } = context;\n    const VueBinding = runtimeGlobalName;\n    // Generate const declaration for helpers\n    // In prefix mode, we place the const declaration at top so it's done\n    // only once; But if we not prefixing, we place the declaration inside the\n    // with block so it doesn't incur the `in` check cost for every helper access.\n    if (ast.helpers.length > 0) {\n        {\n            // \"with\" mode.\n            // save Vue in a separate variable to avoid collision\n            push(`const _Vue = ${VueBinding}\\n`);\n            // in \"with\" mode, helpers are declared inside the with block to avoid\n            // has check cost, but hoists are lifted out of the function - we need\n            // to provide the helper here.\n            if (ast.hoists.length) {\n                const staticHelpers = [\n                    CREATE_VNODE,\n                    CREATE_ELEMENT_VNODE,\n                    CREATE_COMMENT,\n                    CREATE_TEXT,\n                    CREATE_STATIC\n                ]\n                    .filter(helper => ast.helpers.includes(helper))\n                    .map(aliasHelper)\n                    .join(', ');\n                push(`const { ${staticHelpers} } = _Vue\\n`);\n            }\n        }\n    }\n    genHoists(ast.hoists, context);\n    newline();\n    push(`return `);\n}\nfunction genAssets(assets, type, { helper, push, newline, isTS }) {\n    const resolver = helper(type === 'filter'\n        ? RESOLVE_FILTER\n        : type === 'component'\n            ? RESOLVE_COMPONENT\n            : RESOLVE_DIRECTIVE);\n    for (let i = 0; i < assets.length; i++) {\n        let id = assets[i];\n        // potential component implicit self-reference inferred from SFC filename\n        const maybeSelfReference = id.endsWith('__self');\n        if (maybeSelfReference) {\n            id = id.slice(0, -6);\n        }\n        push(`const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`);\n        if (i < assets.length - 1) {\n            newline();\n        }\n    }\n}\nfunction genHoists(hoists, context) {\n    if (!hoists.length) {\n        return;\n    }\n    context.pure = true;\n    const { push, newline, helper, scopeId, mode } = context;\n    newline();\n    for (let i = 0; i < hoists.length; i++) {\n        const exp = hoists[i];\n        if (exp) {\n            push(`const _hoisted_${i + 1} = ${``}`);\n            genNode(exp, context);\n            newline();\n        }\n    }\n    context.pure = false;\n}\nfunction isText$1(n) {\n    return (isString(n) ||\n        n.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ ||\n        n.type === 2 /* NodeTypes.TEXT */ ||\n        n.type === 5 /* NodeTypes.INTERPOLATION */ ||\n        n.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */);\n}\nfunction genNodeListAsArray(nodes, context) {\n    const multilines = nodes.length > 3 ||\n        (((process.env.NODE_ENV !== 'production')) && nodes.some(n => isArray(n) || !isText$1(n)));\n    context.push(`[`);\n    multilines && context.indent();\n    genNodeList(nodes, context, multilines);\n    multilines && context.deindent();\n    context.push(`]`);\n}\nfunction genNodeList(nodes, context, multilines = false, comma = true) {\n    const { push, newline } = context;\n    for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n        if (isString(node)) {\n            push(node);\n        }\n        else if (isArray(node)) {\n            genNodeListAsArray(node, context);\n        }\n        else {\n            genNode(node, context);\n        }\n        if (i < nodes.length - 1) {\n            if (multilines) {\n                comma && push(',');\n                newline();\n            }\n            else {\n                comma && push(', ');\n            }\n        }\n    }\n}\nfunction genNode(node, context) {\n    if (isString(node)) {\n        context.push(node);\n        return;\n    }\n    if (isSymbol(node)) {\n        context.push(context.helper(node));\n        return;\n    }\n    switch (node.type) {\n        case 1 /* NodeTypes.ELEMENT */:\n        case 9 /* NodeTypes.IF */:\n        case 11 /* NodeTypes.FOR */:\n            (process.env.NODE_ENV !== 'production') &&\n                assert(node.codegenNode != null, `Codegen node is missing for element/if/for node. ` +\n                    `Apply appropriate transforms first.`);\n            genNode(node.codegenNode, context);\n            break;\n        case 2 /* NodeTypes.TEXT */:\n            genText(node, context);\n            break;\n        case 4 /* NodeTypes.SIMPLE_EXPRESSION */:\n            genExpression(node, context);\n            break;\n        case 5 /* NodeTypes.INTERPOLATION */:\n            genInterpolation(node, context);\n            break;\n        case 12 /* NodeTypes.TEXT_CALL */:\n            genNode(node.codegenNode, context);\n            break;\n        case 8 /* NodeTypes.COMPOUND_EXPRESSION */:\n            genCompoundExpression(node, context);\n            break;\n        case 3 /* NodeTypes.COMMENT */:\n            genComment(node, context);\n            break;\n        case 13 /* NodeTypes.VNODE_CALL */:\n            genVNodeCall(node, context);\n            break;\n        case 14 /* NodeTypes.JS_CALL_EXPRESSION */:\n            genCallExpression(node, context);\n            break;\n        case 15 /* NodeTypes.JS_OBJECT_EXPRESSION */:\n            genObjectExpression(node, context);\n            break;\n        case 17 /* NodeTypes.JS_ARRAY_EXPRESSION */:\n            genArrayExpression(node, context);\n            break;\n        case 18 /* NodeTypes.JS_FUNCTION_EXPRESSION */:\n            genFunctionExpression(node, context);\n            break;\n        case 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */:\n            genConditionalExpression(node, context);\n            break;\n        case 20 /* NodeTypes.JS_CACHE_EXPRESSION */:\n            genCacheExpression(node, context);\n            break;\n        case 21 /* NodeTypes.JS_BLOCK_STATEMENT */:\n            genNodeList(node.body, context, true, false);\n            break;\n        // SSR only types\n        case 22 /* NodeTypes.JS_TEMPLATE_LITERAL */:\n            break;\n        case 23 /* NodeTypes.JS_IF_STATEMENT */:\n            break;\n        case 24 /* NodeTypes.JS_ASSIGNMENT_EXPRESSION */:\n            break;\n        case 25 /* NodeTypes.JS_SEQUENCE_EXPRESSION */:\n            break;\n        case 26 /* NodeTypes.JS_RETURN_STATEMENT */:\n            break;\n        /* istanbul ignore next */\n        case 10 /* NodeTypes.IF_BRANCH */:\n            // noop\n            break;\n        default:\n            if ((process.env.NODE_ENV !== 'production')) {\n                assert(false, `unhandled codegen node type: ${node.type}`);\n                // make sure we exhaust all possible types\n                const exhaustiveCheck = node;\n                return exhaustiveCheck;\n            }\n    }\n}\nfunction genText(node, context) {\n    context.push(JSON.stringify(node.content), node);\n}\nfunction genExpression(node, context) {\n    const { content, isStatic } = node;\n    context.push(isStatic ? JSON.stringify(content) : content, node);\n}\nfunction genInterpolation(node, context) {\n    const { push, helper, pure } = context;\n    if (pure)\n        push(PURE_ANNOTATION);\n    push(`${helper(TO_DISPLAY_STRING)}(`);\n    genNode(node.content, context);\n    push(`)`);\n}\nfunction genCompoundExpression(node, context) {\n    for (let i = 0; i < node.children.length; i++) {\n        const child = node.children[i];\n        if (isString(child)) {\n            context.push(child);\n        }\n        else {\n            genNode(child, context);\n        }\n    }\n}\nfunction genExpressionAsPropertyKey(node, context) {\n    const { push } = context;\n    if (node.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */) {\n        push(`[`);\n        genCompoundExpression(node, context);\n        push(`]`);\n    }\n    else if (node.isStatic) {\n        // only quote keys if necessary\n        const text = isSimpleIdentifier(node.content)\n            ? node.content\n            : JSON.stringify(node.content);\n        push(text, node);\n    }\n    else {\n        push(`[${node.content}]`, node);\n    }\n}\nfunction genComment(node, context) {\n    const { push, helper, pure } = context;\n    if (pure) {\n        push(PURE_ANNOTATION);\n    }\n    push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, node);\n}\nfunction genVNodeCall(node, context) {\n    const { push, helper, pure } = context;\n    const { tag, props, children, patchFlag, dynamicProps, directives, isBlock, disableTracking, isComponent } = node;\n    if (directives) {\n        push(helper(WITH_DIRECTIVES) + `(`);\n    }\n    if (isBlock) {\n        push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);\n    }\n    if (pure) {\n        push(PURE_ANNOTATION);\n    }\n    const callHelper = isBlock\n        ? getVNodeBlockHelper(context.inSSR, isComponent)\n        : getVNodeHelper(context.inSSR, isComponent);\n    push(helper(callHelper) + `(`, node);\n    genNodeList(genNullableArgs([tag, props, children, patchFlag, dynamicProps]), context);\n    push(`)`);\n    if (isBlock) {\n        push(`)`);\n    }\n    if (directives) {\n        push(`, `);\n        genNode(directives, context);\n        push(`)`);\n    }\n}\nfunction genNullableArgs(args) {\n    let i = args.length;\n    while (i--) {\n        if (args[i] != null)\n            break;\n    }\n    return args.slice(0, i + 1).map(arg => arg || `null`);\n}\n// JavaScript\nfunction genCallExpression(node, context) {\n    const { push, helper, pure } = context;\n    const callee = isString(node.callee) ? node.callee : helper(node.callee);\n    if (pure) {\n        push(PURE_ANNOTATION);\n    }\n    push(callee + `(`, node);\n    genNodeList(node.arguments, context);\n    push(`)`);\n}\nfunction genObjectExpression(node, context) {\n    const { push, indent, deindent, newline } = context;\n    const { properties } = node;\n    if (!properties.length) {\n        push(`{}`, node);\n        return;\n    }\n    const multilines = properties.length > 1 ||\n        (((process.env.NODE_ENV !== 'production')) &&\n            properties.some(p => p.value.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */));\n    push(multilines ? `{` : `{ `);\n    multilines && indent();\n    for (let i = 0; i < properties.length; i++) {\n        const { key, value } = properties[i];\n        // key\n        genExpressionAsPropertyKey(key, context);\n        push(`: `);\n        // value\n        genNode(value, context);\n        if (i < properties.length - 1) {\n            // will only reach this if it's multilines\n            push(`,`);\n            newline();\n        }\n    }\n    multilines && deindent();\n    push(multilines ? `}` : ` }`);\n}\nfunction genArrayExpression(node, context) {\n    genNodeListAsArray(node.elements, context);\n}\nfunction genFunctionExpression(node, context) {\n    const { push, indent, deindent } = context;\n    const { params, returns, body, newline, isSlot } = node;\n    if (isSlot) {\n        // wrap slot functions with owner context\n        push(`_${helperNameMap[WITH_CTX]}(`);\n    }\n    push(`(`, node);\n    if (isArray(params)) {\n        genNodeList(params, context);\n    }\n    else if (params) {\n        genNode(params, context);\n    }\n    push(`) => `);\n    if (newline || body) {\n        push(`{`);\n        indent();\n    }\n    if (returns) {\n        if (newline) {\n            push(`return `);\n        }\n        if (isArray(returns)) {\n            genNodeListAsArray(returns, context);\n        }\n        else {\n            genNode(returns, context);\n        }\n    }\n    else if (body) {\n        genNode(body, context);\n    }\n    if (newline || body) {\n        deindent();\n        push(`}`);\n    }\n    if (isSlot) {\n        if (node.isNonScopedSlot) {\n            push(`, undefined, true`);\n        }\n        push(`)`);\n    }\n}\nfunction genConditionalExpression(node, context) {\n    const { test, consequent, alternate, newline: needNewline } = node;\n    const { push, indent, deindent, newline } = context;\n    if (test.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n        const needsParens = !isSimpleIdentifier(test.content);\n        needsParens && push(`(`);\n        genExpression(test, context);\n        needsParens && push(`)`);\n    }\n    else {\n        push(`(`);\n        genNode(test, context);\n        push(`)`);\n    }\n    needNewline && indent();\n    context.indentLevel++;\n    needNewline || push(` `);\n    push(`? `);\n    genNode(consequent, context);\n    context.indentLevel--;\n    needNewline && newline();\n    needNewline || push(` `);\n    push(`: `);\n    const isNested = alternate.type === 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */;\n    if (!isNested) {\n        context.indentLevel++;\n    }\n    genNode(alternate, context);\n    if (!isNested) {\n        context.indentLevel--;\n    }\n    needNewline && deindent(true /* without newline */);\n}\nfunction genCacheExpression(node, context) {\n    const { push, helper, indent, deindent, newline } = context;\n    push(`_cache[${node.index}] || (`);\n    if (node.isVNode) {\n        indent();\n        push(`${helper(SET_BLOCK_TRACKING)}(-1),`);\n        newline();\n    }\n    push(`_cache[${node.index}] = `);\n    genNode(node.value, context);\n    if (node.isVNode) {\n        push(`,`);\n        newline();\n        push(`${helper(SET_BLOCK_TRACKING)}(1),`);\n        newline();\n        push(`_cache[${node.index}]`);\n        deindent();\n    }\n    push(`)`);\n}\n\nfunction walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = Object.create(null)) {\n    {\n        return;\n    }\n}\nfunction isReferencedIdentifier(id, parent, parentStack) {\n    {\n        return false;\n    }\n}\nfunction isInDestructureAssignment(parent, parentStack) {\n    if (parent &&\n        (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')) {\n        let i = parentStack.length;\n        while (i--) {\n            const p = parentStack[i];\n            if (p.type === 'AssignmentExpression') {\n                return true;\n            }\n            else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) {\n                break;\n            }\n        }\n    }\n    return false;\n}\nfunction walkFunctionParams(node, onIdent) {\n    for (const p of node.params) {\n        for (const id of extractIdentifiers(p)) {\n            onIdent(id);\n        }\n    }\n}\nfunction walkBlockDeclarations(block, onIdent) {\n    for (const stmt of block.body) {\n        if (stmt.type === 'VariableDeclaration') {\n            if (stmt.declare)\n                continue;\n            for (const decl of stmt.declarations) {\n                for (const id of extractIdentifiers(decl.id)) {\n                    onIdent(id);\n                }\n            }\n        }\n        else if (stmt.type === 'FunctionDeclaration' ||\n            stmt.type === 'ClassDeclaration') {\n            if (stmt.declare || !stmt.id)\n                continue;\n            onIdent(stmt.id);\n        }\n    }\n}\nfunction extractIdentifiers(param, nodes = []) {\n    switch (param.type) {\n        case 'Identifier':\n            nodes.push(param);\n            break;\n        case 'MemberExpression':\n            let object = param;\n            while (object.type === 'MemberExpression') {\n                object = object.object;\n            }\n            nodes.push(object);\n            break;\n        case 'ObjectPattern':\n            for (const prop of param.properties) {\n                if (prop.type === 'RestElement') {\n                    extractIdentifiers(prop.argument, nodes);\n                }\n                else {\n                    extractIdentifiers(prop.value, nodes);\n                }\n            }\n            break;\n        case 'ArrayPattern':\n            param.elements.forEach(element => {\n                if (element)\n                    extractIdentifiers(element, nodes);\n            });\n            break;\n        case 'RestElement':\n            extractIdentifiers(param.argument, nodes);\n            break;\n        case 'AssignmentPattern':\n            extractIdentifiers(param.left, nodes);\n            break;\n    }\n    return nodes;\n}\nconst isFunctionType = (node) => {\n    return /Function(?:Expression|Declaration)$|Method$/.test(node.type);\n};\nconst isStaticProperty = (node) => node &&\n    (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&\n    !node.computed;\nconst isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;\n\n// these keywords should not appear inside expressions, but operators like\n// typeof, instanceof and in are allowed\nconst prohibitedKeywordRE = new RegExp('\\\\b' +\n    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +\n        'super,throw,while,yield,delete,export,import,return,switch,default,' +\n        'extends,finally,continue,debugger,function,arguments,typeof,void')\n        .split(',')\n        .join('\\\\b|\\\\b') +\n    '\\\\b');\n// strip strings in expressions\nconst stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n/**\n * Validate a non-prefixed expression.\n * This is only called when using the in-browser runtime compiler since it\n * doesn't prefix expressions.\n */\nfunction validateBrowserExpression(node, context, asParams = false, asRawStatements = false) {\n    const exp = node.content;\n    // empty expressions are validated per-directive since some directives\n    // do allow empty expressions.\n    if (!exp.trim()) {\n        return;\n    }\n    try {\n        new Function(asRawStatements\n            ? ` ${exp} `\n            : `return ${asParams ? `(${exp}) => {}` : `(${exp})`}`);\n    }\n    catch (e) {\n        let message = e.message;\n        const keywordMatch = exp\n            .replace(stripStringRE, '')\n            .match(prohibitedKeywordRE);\n        if (keywordMatch) {\n            message = `avoid using JavaScript keyword as property name: \"${keywordMatch[0]}\"`;\n        }\n        context.onError(createCompilerError(45 /* ErrorCodes.X_INVALID_EXPRESSION */, node.loc, undefined, message));\n    }\n}\n\nconst transformExpression = (node, context) => {\n    if (node.type === 5 /* NodeTypes.INTERPOLATION */) {\n        node.content = processExpression(node.content, context);\n    }\n    else if (node.type === 1 /* NodeTypes.ELEMENT */) {\n        // handle directives on element\n        for (let i = 0; i < node.props.length; i++) {\n            const dir = node.props[i];\n            // do not process for v-on & v-for since they are special handled\n            if (dir.type === 7 /* NodeTypes.DIRECTIVE */ && dir.name !== 'for') {\n                const exp = dir.exp;\n                const arg = dir.arg;\n                // do not process exp if this is v-on:arg - we need special handling\n                // for wrapping inline statements.\n                if (exp &&\n                    exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ &&\n                    !(dir.name === 'on' && arg)) {\n                    dir.exp = processExpression(exp, context, \n                    // slot args must be processed as function params\n                    dir.name === 'slot');\n                }\n                if (arg && arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && !arg.isStatic) {\n                    dir.arg = processExpression(arg, context);\n                }\n            }\n        }\n    }\n};\n// Important: since this function uses Node.js only dependencies, it should\n// always be used with a leading !true check so that it can be\n// tree-shaken from the browser build.\nfunction processExpression(node, context, \n// some expressions like v-slot props & v-for aliases should be parsed as\n// function params\nasParams = false, \n// v-on handler values may contain multiple statements\nasRawStatements = false, localVars = Object.create(context.identifiers)) {\n    {\n        if ((process.env.NODE_ENV !== 'production')) {\n            // simple in-browser validation (same logic in 2.x)\n            validateBrowserExpression(node, context, asParams, asRawStatements);\n        }\n        return node;\n    }\n}\nfunction stringifyExpression(exp) {\n    if (isString(exp)) {\n        return exp;\n    }\n    else if (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n        return exp.content;\n    }\n    else {\n        return exp.children\n            .map(stringifyExpression)\n            .join('');\n    }\n}\n\nconst transformIf = createStructuralDirectiveTransform(/^(if|else|else-if)$/, (node, dir, context) => {\n    return processIf(node, dir, context, (ifNode, branch, isRoot) => {\n        // #1587: We need to dynamically increment the key based on the current\n        // node's sibling nodes, since chained v-if/else branches are\n        // rendered at the same depth\n        const siblings = context.parent.children;\n        let i = siblings.indexOf(ifNode);\n        let key = 0;\n        while (i-- >= 0) {\n            const sibling = siblings[i];\n            if (sibling && sibling.type === 9 /* NodeTypes.IF */) {\n                key += sibling.branches.length;\n            }\n        }\n        // Exit callback. Complete the codegenNode when all children have been\n        // transformed.\n        return () => {\n            if (isRoot) {\n                ifNode.codegenNode = createCodegenNodeForBranch(branch, key, context);\n            }\n            else {\n                // attach this branch's codegen node to the v-if root.\n                const parentCondition = getParentCondition(ifNode.codegenNode);\n                parentCondition.alternate = createCodegenNodeForBranch(branch, key + ifNode.branches.length - 1, context);\n            }\n        };\n    });\n});\n// target-agnostic transform used for both Client and SSR\nfunction processIf(node, dir, context, processCodegen) {\n    if (dir.name !== 'else' &&\n        (!dir.exp || !dir.exp.content.trim())) {\n        const loc = dir.exp ? dir.exp.loc : node.loc;\n        context.onError(createCompilerError(28 /* ErrorCodes.X_V_IF_NO_EXPRESSION */, dir.loc));\n        dir.exp = createSimpleExpression(`true`, false, loc);\n    }\n    if ((process.env.NODE_ENV !== 'production') && true && dir.exp) {\n        validateBrowserExpression(dir.exp, context);\n    }\n    if (dir.name === 'if') {\n        const branch = createIfBranch(node, dir);\n        const ifNode = {\n            type: 9 /* NodeTypes.IF */,\n            loc: node.loc,\n            branches: [branch]\n        };\n        context.replaceNode(ifNode);\n        if (processCodegen) {\n            return processCodegen(ifNode, branch, true);\n        }\n    }\n    else {\n        // locate the adjacent v-if\n        const siblings = context.parent.children;\n        const comments = [];\n        let i = siblings.indexOf(node);\n        while (i-- >= -1) {\n            const sibling = siblings[i];\n            if (sibling && sibling.type === 3 /* NodeTypes.COMMENT */) {\n                context.removeNode(sibling);\n                (process.env.NODE_ENV !== 'production') && comments.unshift(sibling);\n                continue;\n            }\n            if (sibling &&\n                sibling.type === 2 /* NodeTypes.TEXT */ &&\n                !sibling.content.trim().length) {\n                context.removeNode(sibling);\n                continue;\n            }\n            if (sibling && sibling.type === 9 /* NodeTypes.IF */) {\n                // Check if v-else was followed by v-else-if\n                if (dir.name === 'else-if' &&\n                    sibling.branches[sibling.branches.length - 1].condition === undefined) {\n                    context.onError(createCompilerError(30 /* ErrorCodes.X_V_ELSE_NO_ADJACENT_IF */, node.loc));\n                }\n                // move the node to the if node's branches\n                context.removeNode();\n                const branch = createIfBranch(node, dir);\n                if ((process.env.NODE_ENV !== 'production') &&\n                    comments.length &&\n                    // #3619 ignore comments if the v-if is direct child of <transition>\n                    !(context.parent &&\n                        context.parent.type === 1 /* NodeTypes.ELEMENT */ &&\n                        isBuiltInType(context.parent.tag, 'transition'))) {\n                    branch.children = [...comments, ...branch.children];\n                }\n                // check if user is forcing same key on different branches\n                if ((process.env.NODE_ENV !== 'production') || !true) {\n                    const key = branch.userKey;\n                    if (key) {\n                        sibling.branches.forEach(({ userKey }) => {\n                            if (isSameKey(userKey, key)) {\n                                context.onError(createCompilerError(29 /* ErrorCodes.X_V_IF_SAME_KEY */, branch.userKey.loc));\n                            }\n                        });\n                    }\n                }\n                sibling.branches.push(branch);\n                const onExit = processCodegen && processCodegen(sibling, branch, false);\n                // since the branch was removed, it will not be traversed.\n                // make sure to traverse here.\n                traverseNode(branch, context);\n                // call on exit\n                if (onExit)\n                    onExit();\n                // make sure to reset currentNode after traversal to indicate this\n                // node has been removed.\n                context.currentNode = null;\n            }\n            else {\n                context.onError(createCompilerError(30 /* ErrorCodes.X_V_ELSE_NO_ADJACENT_IF */, node.loc));\n            }\n            break;\n        }\n    }\n}\nfunction createIfBranch(node, dir) {\n    const isTemplateIf = node.tagType === 3 /* ElementTypes.TEMPLATE */;\n    return {\n        type: 10 /* NodeTypes.IF_BRANCH */,\n        loc: node.loc,\n        condition: dir.name === 'else' ? undefined : dir.exp,\n        children: isTemplateIf && !findDir(node, 'for') ? node.children : [node],\n        userKey: findProp(node, `key`),\n        isTemplateIf\n    };\n}\nfunction createCodegenNodeForBranch(branch, keyIndex, context) {\n    if (branch.condition) {\n        return createConditionalExpression(branch.condition, createChildrenCodegenNode(branch, keyIndex, context), \n        // make sure to pass in asBlock: true so that the comment node call\n        // closes the current block.\n        createCallExpression(context.helper(CREATE_COMMENT), [\n            (process.env.NODE_ENV !== 'production') ? '\"v-if\"' : '\"\"',\n            'true'\n        ]));\n    }\n    else {\n        return createChildrenCodegenNode(branch, keyIndex, context);\n    }\n}\nfunction createChildrenCodegenNode(branch, keyIndex, context) {\n    const { helper } = context;\n    const keyProperty = createObjectProperty(`key`, createSimpleExpression(`${keyIndex}`, false, locStub, 2 /* ConstantTypes.CAN_HOIST */));\n    const { children } = branch;\n    const firstChild = children[0];\n    const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1 /* NodeTypes.ELEMENT */;\n    if (needFragmentWrapper) {\n        if (children.length === 1 && firstChild.type === 11 /* NodeTypes.FOR */) {\n            // optimize away nested fragments when child is a ForNode\n            const vnodeCall = firstChild.codegenNode;\n            injectProp(vnodeCall, keyProperty, context);\n            return vnodeCall;\n        }\n        else {\n            let patchFlag = 64 /* PatchFlags.STABLE_FRAGMENT */;\n            let patchFlagText = PatchFlagNames[64 /* PatchFlags.STABLE_FRAGMENT */];\n            // check if the fragment actually contains a single valid child with\n            // the rest being comments\n            if ((process.env.NODE_ENV !== 'production') &&\n                !branch.isTemplateIf &&\n                children.filter(c => c.type !== 3 /* NodeTypes.COMMENT */).length === 1) {\n                patchFlag |= 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */;\n                patchFlagText += `, ${PatchFlagNames[2048 /* PatchFlags.DEV_ROOT_FRAGMENT */]}`;\n            }\n            return createVNodeCall(context, helper(FRAGMENT), createObjectExpression([keyProperty]), children, patchFlag + ((process.env.NODE_ENV !== 'production') ? ` /* ${patchFlagText} */` : ``), undefined, undefined, true, false, false /* isComponent */, branch.loc);\n        }\n    }\n    else {\n        const ret = firstChild.codegenNode;\n        const vnodeCall = getMemoedVNodeCall(ret);\n        // Change createVNode to createBlock.\n        if (vnodeCall.type === 13 /* NodeTypes.VNODE_CALL */) {\n            makeBlock(vnodeCall, context);\n        }\n        // inject branch key\n        injectProp(vnodeCall, keyProperty, context);\n        return ret;\n    }\n}\nfunction isSameKey(a, b) {\n    if (!a || a.type !== b.type) {\n        return false;\n    }\n    if (a.type === 6 /* NodeTypes.ATTRIBUTE */) {\n        if (a.value.content !== b.value.content) {\n            return false;\n        }\n    }\n    else {\n        // directive\n        const exp = a.exp;\n        const branchExp = b.exp;\n        if (exp.type !== branchExp.type) {\n            return false;\n        }\n        if (exp.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */ ||\n            exp.isStatic !== branchExp.isStatic ||\n            exp.content !== branchExp.content) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction getParentCondition(node) {\n    while (true) {\n        if (node.type === 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */) {\n            if (node.alternate.type === 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */) {\n                node = node.alternate;\n            }\n            else {\n                return node;\n            }\n        }\n        else if (node.type === 20 /* NodeTypes.JS_CACHE_EXPRESSION */) {\n            node = node.value;\n        }\n    }\n}\n\nconst transformFor = createStructuralDirectiveTransform('for', (node, dir, context) => {\n    const { helper, removeHelper } = context;\n    return processFor(node, dir, context, forNode => {\n        // create the loop render function expression now, and add the\n        // iterator on exit after all children have been traversed\n        const renderExp = createCallExpression(helper(RENDER_LIST), [\n            forNode.source\n        ]);\n        const isTemplate = isTemplateNode(node);\n        const memo = findDir(node, 'memo');\n        const keyProp = findProp(node, `key`);\n        const keyExp = keyProp &&\n            (keyProp.type === 6 /* NodeTypes.ATTRIBUTE */\n                ? createSimpleExpression(keyProp.value.content, true)\n                : keyProp.exp);\n        const keyProperty = keyProp ? createObjectProperty(`key`, keyExp) : null;\n        const isStableFragment = forNode.source.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ &&\n            forNode.source.constType > 0 /* ConstantTypes.NOT_CONSTANT */;\n        const fragmentFlag = isStableFragment\n            ? 64 /* PatchFlags.STABLE_FRAGMENT */\n            : keyProp\n                ? 128 /* PatchFlags.KEYED_FRAGMENT */\n                : 256 /* PatchFlags.UNKEYED_FRAGMENT */;\n        forNode.codegenNode = createVNodeCall(context, helper(FRAGMENT), undefined, renderExp, fragmentFlag +\n            ((process.env.NODE_ENV !== 'production') ? ` /* ${PatchFlagNames[fragmentFlag]} */` : ``), undefined, undefined, true /* isBlock */, !isStableFragment /* disableTracking */, false /* isComponent */, node.loc);\n        return () => {\n            // finish the codegen now that all children have been traversed\n            let childBlock;\n            const { children } = forNode;\n            // check <template v-for> key placement\n            if (((process.env.NODE_ENV !== 'production') || !true) && isTemplate) {\n                node.children.some(c => {\n                    if (c.type === 1 /* NodeTypes.ELEMENT */) {\n                        const key = findProp(c, 'key');\n                        if (key) {\n                            context.onError(createCompilerError(33 /* ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT */, key.loc));\n                            return true;\n                        }\n                    }\n                });\n            }\n            const needFragmentWrapper = children.length !== 1 || children[0].type !== 1 /* NodeTypes.ELEMENT */;\n            const slotOutlet = isSlotOutlet(node)\n                ? node\n                : isTemplate &&\n                    node.children.length === 1 &&\n                    isSlotOutlet(node.children[0])\n                    ? node.children[0] // api-extractor somehow fails to infer this\n                    : null;\n            if (slotOutlet) {\n                // <slot v-for=\"...\"> or <template v-for=\"...\"><slot/></template>\n                childBlock = slotOutlet.codegenNode;\n                if (isTemplate && keyProperty) {\n                    // <template v-for=\"...\" :key=\"...\"><slot/></template>\n                    // we need to inject the key to the renderSlot() call.\n                    // the props for renderSlot is passed as the 3rd argument.\n                    injectProp(childBlock, keyProperty, context);\n                }\n            }\n            else if (needFragmentWrapper) {\n                // <template v-for=\"...\"> with text or multi-elements\n                // should generate a fragment block for each loop\n                childBlock = createVNodeCall(context, helper(FRAGMENT), keyProperty ? createObjectExpression([keyProperty]) : undefined, node.children, 64 /* PatchFlags.STABLE_FRAGMENT */ +\n                    ((process.env.NODE_ENV !== 'production')\n                        ? ` /* ${PatchFlagNames[64 /* PatchFlags.STABLE_FRAGMENT */]} */`\n                        : ``), undefined, undefined, true, undefined, false /* isComponent */);\n            }\n            else {\n                // Normal element v-for. Directly use the child's codegenNode\n                // but mark it as a block.\n                childBlock = children[0]\n                    .codegenNode;\n                if (isTemplate && keyProperty) {\n                    injectProp(childBlock, keyProperty, context);\n                }\n                if (childBlock.isBlock !== !isStableFragment) {\n                    if (childBlock.isBlock) {\n                        // switch from block to vnode\n                        removeHelper(OPEN_BLOCK);\n                        removeHelper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));\n                    }\n                    else {\n                        // switch from vnode to block\n                        removeHelper(getVNodeHelper(context.inSSR, childBlock.isComponent));\n                    }\n                }\n                childBlock.isBlock = !isStableFragment;\n                if (childBlock.isBlock) {\n                    helper(OPEN_BLOCK);\n                    helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));\n                }\n                else {\n                    helper(getVNodeHelper(context.inSSR, childBlock.isComponent));\n                }\n            }\n            if (memo) {\n                const loop = createFunctionExpression(createForLoopParams(forNode.parseResult, [\n                    createSimpleExpression(`_cached`)\n                ]));\n                loop.body = createBlockStatement([\n                    createCompoundExpression([`const _memo = (`, memo.exp, `)`]),\n                    createCompoundExpression([\n                        `if (_cached`,\n                        ...(keyExp ? [` && _cached.key === `, keyExp] : []),\n                        ` && ${context.helperString(IS_MEMO_SAME)}(_cached, _memo)) return _cached`\n                    ]),\n                    createCompoundExpression([`const _item = `, childBlock]),\n                    createSimpleExpression(`_item.memo = _memo`),\n                    createSimpleExpression(`return _item`)\n                ]);\n                renderExp.arguments.push(loop, createSimpleExpression(`_cache`), createSimpleExpression(String(context.cached++)));\n            }\n            else {\n                renderExp.arguments.push(createFunctionExpression(createForLoopParams(forNode.parseResult), childBlock, true /* force newline */));\n            }\n        };\n    });\n});\n// target-agnostic transform used for both Client and SSR\nfunction processFor(node, dir, context, processCodegen) {\n    if (!dir.exp) {\n        context.onError(createCompilerError(31 /* ErrorCodes.X_V_FOR_NO_EXPRESSION */, dir.loc));\n        return;\n    }\n    const parseResult = parseForExpression(\n    // can only be simple expression because vFor transform is applied\n    // before expression transform.\n    dir.exp, context);\n    if (!parseResult) {\n        context.onError(createCompilerError(32 /* ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION */, dir.loc));\n        return;\n    }\n    const { addIdentifiers, removeIdentifiers, scopes } = context;\n    const { source, value, key, index } = parseResult;\n    const forNode = {\n        type: 11 /* NodeTypes.FOR */,\n        loc: dir.loc,\n        source,\n        valueAlias: value,\n        keyAlias: key,\n        objectIndexAlias: index,\n        parseResult,\n        children: isTemplateNode(node) ? node.children : [node]\n    };\n    context.replaceNode(forNode);\n    // bookkeeping\n    scopes.vFor++;\n    const onExit = processCodegen && processCodegen(forNode);\n    return () => {\n        scopes.vFor--;\n        if (onExit)\n            onExit();\n    };\n}\nconst forAliasRE = /([\\s\\S]*?)\\s+(?:in|of)\\s+([\\s\\S]*)/;\n// This regex doesn't cover the case if key or index aliases have destructuring,\n// but those do not make sense in the first place, so this works in practice.\nconst forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/;\nconst stripParensRE = /^\\(|\\)$/g;\nfunction parseForExpression(input, context) {\n    const loc = input.loc;\n    const exp = input.content;\n    const inMatch = exp.match(forAliasRE);\n    if (!inMatch)\n        return;\n    const [, LHS, RHS] = inMatch;\n    const result = {\n        source: createAliasExpression(loc, RHS.trim(), exp.indexOf(RHS, LHS.length)),\n        value: undefined,\n        key: undefined,\n        index: undefined\n    };\n    if ((process.env.NODE_ENV !== 'production') && true) {\n        validateBrowserExpression(result.source, context);\n    }\n    let valueContent = LHS.trim().replace(stripParensRE, '').trim();\n    const trimmedOffset = LHS.indexOf(valueContent);\n    const iteratorMatch = valueContent.match(forIteratorRE);\n    if (iteratorMatch) {\n        valueContent = valueContent.replace(forIteratorRE, '').trim();\n        const keyContent = iteratorMatch[1].trim();\n        let keyOffset;\n        if (keyContent) {\n            keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);\n            result.key = createAliasExpression(loc, keyContent, keyOffset);\n            if ((process.env.NODE_ENV !== 'production') && true) {\n                validateBrowserExpression(result.key, context, true);\n            }\n        }\n        if (iteratorMatch[2]) {\n            const indexContent = iteratorMatch[2].trim();\n            if (indexContent) {\n                result.index = createAliasExpression(loc, indexContent, exp.indexOf(indexContent, result.key\n                    ? keyOffset + keyContent.length\n                    : trimmedOffset + valueContent.length));\n                if ((process.env.NODE_ENV !== 'production') && true) {\n                    validateBrowserExpression(result.index, context, true);\n                }\n            }\n        }\n    }\n    if (valueContent) {\n        result.value = createAliasExpression(loc, valueContent, trimmedOffset);\n        if ((process.env.NODE_ENV !== 'production') && true) {\n            validateBrowserExpression(result.value, context, true);\n        }\n    }\n    return result;\n}\nfunction createAliasExpression(range, content, offset) {\n    return createSimpleExpression(content, false, getInnerRange(range, offset, content.length));\n}\nfunction createForLoopParams({ value, key, index }, memoArgs = []) {\n    return createParamsList([value, key, index, ...memoArgs]);\n}\nfunction createParamsList(args) {\n    let i = args.length;\n    while (i--) {\n        if (args[i])\n            break;\n    }\n    return args\n        .slice(0, i + 1)\n        .map((arg, i) => arg || createSimpleExpression(`_`.repeat(i + 1), false));\n}\n\nconst defaultFallback = createSimpleExpression(`undefined`, false);\n// A NodeTransform that:\n// 1. Tracks scope identifiers for scoped slots so that they don't get prefixed\n//    by transformExpression. This is only applied in non-browser builds with\n//    { prefixIdentifiers: true }.\n// 2. Track v-slot depths so that we know a slot is inside another slot.\n//    Note the exit callback is executed before buildSlots() on the same node,\n//    so only nested slots see positive numbers.\nconst trackSlotScopes = (node, context) => {\n    if (node.type === 1 /* NodeTypes.ELEMENT */ &&\n        (node.tagType === 1 /* ElementTypes.COMPONENT */ ||\n            node.tagType === 3 /* ElementTypes.TEMPLATE */)) {\n        // We are only checking non-empty v-slot here\n        // since we only care about slots that introduce scope variables.\n        const vSlot = findDir(node, 'slot');\n        if (vSlot) {\n            vSlot.exp;\n            context.scopes.vSlot++;\n            return () => {\n                context.scopes.vSlot--;\n            };\n        }\n    }\n};\n// A NodeTransform that tracks scope identifiers for scoped slots with v-for.\n// This transform is only applied in non-browser builds with { prefixIdentifiers: true }\nconst trackVForSlotScopes = (node, context) => {\n    let vFor;\n    if (isTemplateNode(node) &&\n        node.props.some(isVSlot) &&\n        (vFor = findDir(node, 'for'))) {\n        const result = (vFor.parseResult = parseForExpression(vFor.exp, context));\n        if (result) {\n            const { value, key, index } = result;\n            const { addIdentifiers, removeIdentifiers } = context;\n            value && addIdentifiers(value);\n            key && addIdentifiers(key);\n            index && addIdentifiers(index);\n            return () => {\n                value && removeIdentifiers(value);\n                key && removeIdentifiers(key);\n                index && removeIdentifiers(index);\n            };\n        }\n    }\n};\nconst buildClientSlotFn = (props, children, loc) => createFunctionExpression(props, children, false /* newline */, true /* isSlot */, children.length ? children[0].loc : loc);\n// Instead of being a DirectiveTransform, v-slot processing is called during\n// transformElement to build the slots object for a component.\nfunction buildSlots(node, context, buildSlotFn = buildClientSlotFn) {\n    context.helper(WITH_CTX);\n    const { children, loc } = node;\n    const slotsProperties = [];\n    const dynamicSlots = [];\n    // If the slot is inside a v-for or another v-slot, force it to be dynamic\n    // since it likely uses a scope variable.\n    let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;\n    // 1. Check for slot with slotProps on component itself.\n    //    <Comp v-slot=\"{ prop }\"/>\n    const onComponentSlot = findDir(node, 'slot', true);\n    if (onComponentSlot) {\n        const { arg, exp } = onComponentSlot;\n        if (arg && !isStaticExp(arg)) {\n            hasDynamicSlots = true;\n        }\n        slotsProperties.push(createObjectProperty(arg || createSimpleExpression('default', true), buildSlotFn(exp, children, loc)));\n    }\n    // 2. Iterate through children and check for template slots\n    //    <template v-slot:foo=\"{ prop }\">\n    let hasTemplateSlots = false;\n    let hasNamedDefaultSlot = false;\n    const implicitDefaultChildren = [];\n    const seenSlotNames = new Set();\n    let conditionalBranchIndex = 0;\n    for (let i = 0; i < children.length; i++) {\n        const slotElement = children[i];\n        let slotDir;\n        if (!isTemplateNode(slotElement) ||\n            !(slotDir = findDir(slotElement, 'slot', true))) {\n            // not a <template v-slot>, skip.\n            if (slotElement.type !== 3 /* NodeTypes.COMMENT */) {\n                implicitDefaultChildren.push(slotElement);\n            }\n            continue;\n        }\n        if (onComponentSlot) {\n            // already has on-component slot - this is incorrect usage.\n            context.onError(createCompilerError(37 /* ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE */, slotDir.loc));\n            break;\n        }\n        hasTemplateSlots = true;\n        const { children: slotChildren, loc: slotLoc } = slotElement;\n        const { arg: slotName = createSimpleExpression(`default`, true), exp: slotProps, loc: dirLoc } = slotDir;\n        // check if name is dynamic.\n        let staticSlotName;\n        if (isStaticExp(slotName)) {\n            staticSlotName = slotName ? slotName.content : `default`;\n        }\n        else {\n            hasDynamicSlots = true;\n        }\n        const slotFunction = buildSlotFn(slotProps, slotChildren, slotLoc);\n        // check if this slot is conditional (v-if/v-for)\n        let vIf;\n        let vElse;\n        let vFor;\n        if ((vIf = findDir(slotElement, 'if'))) {\n            hasDynamicSlots = true;\n            dynamicSlots.push(createConditionalExpression(vIf.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback));\n        }\n        else if ((vElse = findDir(slotElement, /^else(-if)?$/, true /* allowEmpty */))) {\n            // find adjacent v-if\n            let j = i;\n            let prev;\n            while (j--) {\n                prev = children[j];\n                if (prev.type !== 3 /* NodeTypes.COMMENT */) {\n                    break;\n                }\n            }\n            if (prev && isTemplateNode(prev) && findDir(prev, 'if')) {\n                // remove node\n                children.splice(i, 1);\n                i--;\n                // attach this slot to previous conditional\n                let conditional = dynamicSlots[dynamicSlots.length - 1];\n                while (conditional.alternate.type === 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */) {\n                    conditional = conditional.alternate;\n                }\n                conditional.alternate = vElse.exp\n                    ? createConditionalExpression(vElse.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback)\n                    : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);\n            }\n            else {\n                context.onError(createCompilerError(30 /* ErrorCodes.X_V_ELSE_NO_ADJACENT_IF */, vElse.loc));\n            }\n        }\n        else if ((vFor = findDir(slotElement, 'for'))) {\n            hasDynamicSlots = true;\n            const parseResult = vFor.parseResult ||\n                parseForExpression(vFor.exp, context);\n            if (parseResult) {\n                // Render the dynamic slots as an array and add it to the createSlot()\n                // args. The runtime knows how to handle it appropriately.\n                dynamicSlots.push(createCallExpression(context.helper(RENDER_LIST), [\n                    parseResult.source,\n                    createFunctionExpression(createForLoopParams(parseResult), buildDynamicSlot(slotName, slotFunction), true /* force newline */)\n                ]));\n            }\n            else {\n                context.onError(createCompilerError(32 /* ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION */, vFor.loc));\n            }\n        }\n        else {\n            // check duplicate static names\n            if (staticSlotName) {\n                if (seenSlotNames.has(staticSlotName)) {\n                    context.onError(createCompilerError(38 /* ErrorCodes.X_V_SLOT_DUPLICATE_SLOT_NAMES */, dirLoc));\n                    continue;\n                }\n                seenSlotNames.add(staticSlotName);\n                if (staticSlotName === 'default') {\n                    hasNamedDefaultSlot = true;\n                }\n            }\n            slotsProperties.push(createObjectProperty(slotName, slotFunction));\n        }\n    }\n    if (!onComponentSlot) {\n        const buildDefaultSlotProperty = (props, children) => {\n            const fn = buildSlotFn(props, children, loc);\n            if (context.compatConfig) {\n                fn.isNonScopedSlot = true;\n            }\n            return createObjectProperty(`default`, fn);\n        };\n        if (!hasTemplateSlots) {\n            // implicit default slot (on component)\n            slotsProperties.push(buildDefaultSlotProperty(undefined, children));\n        }\n        else if (implicitDefaultChildren.length &&\n            // #3766\n            // with whitespace: 'preserve', whitespaces between slots will end up in\n            // implicitDefaultChildren. Ignore if all implicit children are whitespaces.\n            implicitDefaultChildren.some(node => isNonWhitespaceContent(node))) {\n            // implicit default slot (mixed with named slots)\n            if (hasNamedDefaultSlot) {\n                context.onError(createCompilerError(39 /* ErrorCodes.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN */, implicitDefaultChildren[0].loc));\n            }\n            else {\n                slotsProperties.push(buildDefaultSlotProperty(undefined, implicitDefaultChildren));\n            }\n        }\n    }\n    const slotFlag = hasDynamicSlots\n        ? 2 /* SlotFlags.DYNAMIC */\n        : hasForwardedSlots(node.children)\n            ? 3 /* SlotFlags.FORWARDED */\n            : 1 /* SlotFlags.STABLE */;\n    let slots = createObjectExpression(slotsProperties.concat(createObjectProperty(`_`, \n    // 2 = compiled but dynamic = can skip normalization, but must run diff\n    // 1 = compiled and static = can skip normalization AND diff as optimized\n    createSimpleExpression(slotFlag + ((process.env.NODE_ENV !== 'production') ? ` /* ${slotFlagsText[slotFlag]} */` : ``), false))), loc);\n    if (dynamicSlots.length) {\n        slots = createCallExpression(context.helper(CREATE_SLOTS), [\n            slots,\n            createArrayExpression(dynamicSlots)\n        ]);\n    }\n    return {\n        slots,\n        hasDynamicSlots\n    };\n}\nfunction buildDynamicSlot(name, fn, index) {\n    const props = [\n        createObjectProperty(`name`, name),\n        createObjectProperty(`fn`, fn)\n    ];\n    if (index != null) {\n        props.push(createObjectProperty(`key`, createSimpleExpression(String(index), true)));\n    }\n    return createObjectExpression(props);\n}\nfunction hasForwardedSlots(children) {\n    for (let i = 0; i < children.length; i++) {\n        const child = children[i];\n        switch (child.type) {\n            case 1 /* NodeTypes.ELEMENT */:\n                if (child.tagType === 2 /* ElementTypes.SLOT */ ||\n                    hasForwardedSlots(child.children)) {\n                    return true;\n                }\n                break;\n            case 9 /* NodeTypes.IF */:\n                if (hasForwardedSlots(child.branches))\n                    return true;\n                break;\n            case 10 /* NodeTypes.IF_BRANCH */:\n            case 11 /* NodeTypes.FOR */:\n                if (hasForwardedSlots(child.children))\n                    return true;\n                break;\n        }\n    }\n    return false;\n}\nfunction isNonWhitespaceContent(node) {\n    if (node.type !== 2 /* NodeTypes.TEXT */ && node.type !== 12 /* NodeTypes.TEXT_CALL */)\n        return true;\n    return node.type === 2 /* NodeTypes.TEXT */\n        ? !!node.content.trim()\n        : isNonWhitespaceContent(node.content);\n}\n\n// some directive transforms (e.g. v-model) may return a symbol for runtime\n// import, which should be used instead of a resolveDirective call.\nconst directiveImportMap = new WeakMap();\n// generate a JavaScript AST for this element's codegen\nconst transformElement = (node, context) => {\n    // perform the work on exit, after all child expressions have been\n    // processed and merged.\n    return function postTransformElement() {\n        node = context.currentNode;\n        if (!(node.type === 1 /* NodeTypes.ELEMENT */ &&\n            (node.tagType === 0 /* ElementTypes.ELEMENT */ ||\n                node.tagType === 1 /* ElementTypes.COMPONENT */))) {\n            return;\n        }\n        const { tag, props } = node;\n        const isComponent = node.tagType === 1 /* ElementTypes.COMPONENT */;\n        // The goal of the transform is to create a codegenNode implementing the\n        // VNodeCall interface.\n        let vnodeTag = isComponent\n            ? resolveComponentType(node, context)\n            : `\"${tag}\"`;\n        const isDynamicComponent = isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;\n        let vnodeProps;\n        let vnodeChildren;\n        let vnodePatchFlag;\n        let patchFlag = 0;\n        let vnodeDynamicProps;\n        let dynamicPropNames;\n        let vnodeDirectives;\n        let shouldUseBlock = \n        // dynamic component may resolve to plain elements\n        isDynamicComponent ||\n            vnodeTag === TELEPORT ||\n            vnodeTag === SUSPENSE ||\n            (!isComponent &&\n                // <svg> and <foreignObject> must be forced into blocks so that block\n                // updates inside get proper isSVG flag at runtime. (#639, #643)\n                // This is technically web-specific, but splitting the logic out of core\n                // leads to too much unnecessary complexity.\n                (tag === 'svg' || tag === 'foreignObject'));\n        // props\n        if (props.length > 0) {\n            const propsBuildResult = buildProps(node, context, undefined, isComponent, isDynamicComponent);\n            vnodeProps = propsBuildResult.props;\n            patchFlag = propsBuildResult.patchFlag;\n            dynamicPropNames = propsBuildResult.dynamicPropNames;\n            const directives = propsBuildResult.directives;\n            vnodeDirectives =\n                directives && directives.length\n                    ? createArrayExpression(directives.map(dir => buildDirectiveArgs(dir, context)))\n                    : undefined;\n            if (propsBuildResult.shouldUseBlock) {\n                shouldUseBlock = true;\n            }\n        }\n        // children\n        if (node.children.length > 0) {\n            if (vnodeTag === KEEP_ALIVE) {\n                // Although a built-in component, we compile KeepAlive with raw children\n                // instead of slot functions so that it can be used inside Transition\n                // or other Transition-wrapping HOCs.\n                // To ensure correct updates with block optimizations, we need to:\n                // 1. Force keep-alive into a block. This avoids its children being\n                //    collected by a parent block.\n                shouldUseBlock = true;\n                // 2. Force keep-alive to always be updated, since it uses raw children.\n                patchFlag |= 1024 /* PatchFlags.DYNAMIC_SLOTS */;\n                if ((process.env.NODE_ENV !== 'production') && node.children.length > 1) {\n                    context.onError(createCompilerError(46 /* ErrorCodes.X_KEEP_ALIVE_INVALID_CHILDREN */, {\n                        start: node.children[0].loc.start,\n                        end: node.children[node.children.length - 1].loc.end,\n                        source: ''\n                    }));\n                }\n            }\n            const shouldBuildAsSlots = isComponent &&\n                // Teleport is not a real component and has dedicated runtime handling\n                vnodeTag !== TELEPORT &&\n                // explained above.\n                vnodeTag !== KEEP_ALIVE;\n            if (shouldBuildAsSlots) {\n                const { slots, hasDynamicSlots } = buildSlots(node, context);\n                vnodeChildren = slots;\n                if (hasDynamicSlots) {\n                    patchFlag |= 1024 /* PatchFlags.DYNAMIC_SLOTS */;\n                }\n            }\n            else if (node.children.length === 1 && vnodeTag !== TELEPORT) {\n                const child = node.children[0];\n                const type = child.type;\n                // check for dynamic text children\n                const hasDynamicTextChild = type === 5 /* NodeTypes.INTERPOLATION */ ||\n                    type === 8 /* NodeTypes.COMPOUND_EXPRESSION */;\n                if (hasDynamicTextChild &&\n                    getConstantType(child, context) === 0 /* ConstantTypes.NOT_CONSTANT */) {\n                    patchFlag |= 1 /* PatchFlags.TEXT */;\n                }\n                // pass directly if the only child is a text node\n                // (plain / interpolation / expression)\n                if (hasDynamicTextChild || type === 2 /* NodeTypes.TEXT */) {\n                    vnodeChildren = child;\n                }\n                else {\n                    vnodeChildren = node.children;\n                }\n            }\n            else {\n                vnodeChildren = node.children;\n            }\n        }\n        // patchFlag & dynamicPropNames\n        if (patchFlag !== 0) {\n            if ((process.env.NODE_ENV !== 'production')) {\n                if (patchFlag < 0) {\n                    // special flags (negative and mutually exclusive)\n                    vnodePatchFlag = patchFlag + ` /* ${PatchFlagNames[patchFlag]} */`;\n                }\n                else {\n                    // bitwise flags\n                    const flagNames = Object.keys(PatchFlagNames)\n                        .map(Number)\n                        .filter(n => n > 0 && patchFlag & n)\n                        .map(n => PatchFlagNames[n])\n                        .join(`, `);\n                    vnodePatchFlag = patchFlag + ` /* ${flagNames} */`;\n                }\n            }\n            else {\n                vnodePatchFlag = String(patchFlag);\n            }\n            if (dynamicPropNames && dynamicPropNames.length) {\n                vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);\n            }\n        }\n        node.codegenNode = createVNodeCall(context, vnodeTag, vnodeProps, vnodeChildren, vnodePatchFlag, vnodeDynamicProps, vnodeDirectives, !!shouldUseBlock, false /* disableTracking */, isComponent, node.loc);\n    };\n};\nfunction resolveComponentType(node, context, ssr = false) {\n    let { tag } = node;\n    // 1. dynamic component\n    const isExplicitDynamic = isComponentTag(tag);\n    const isProp = findProp(node, 'is');\n    if (isProp) {\n        if (isExplicitDynamic ||\n            (isCompatEnabled(\"COMPILER_IS_ON_ELEMENT\" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */, context))) {\n            const exp = isProp.type === 6 /* NodeTypes.ATTRIBUTE */\n                ? isProp.value && createSimpleExpression(isProp.value.content, true)\n                : isProp.exp;\n            if (exp) {\n                return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [\n                    exp\n                ]);\n            }\n        }\n        else if (isProp.type === 6 /* NodeTypes.ATTRIBUTE */ &&\n            isProp.value.content.startsWith('vue:')) {\n            // <button is=\"vue:xxx\">\n            // if not <component>, only is value that starts with \"vue:\" will be\n            // treated as component by the parse phase and reach here, unless it's\n            // compat mode where all is values are considered components\n            tag = isProp.value.content.slice(4);\n        }\n    }\n    // 1.5 v-is (TODO: Deprecate)\n    const isDir = !isExplicitDynamic && findDir(node, 'is');\n    if (isDir && isDir.exp) {\n        return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [\n            isDir.exp\n        ]);\n    }\n    // 2. built-in components (Teleport, Transition, KeepAlive, Suspense...)\n    const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);\n    if (builtIn) {\n        // built-ins are simply fallthroughs / have special handling during ssr\n        // so we don't need to import their runtime equivalents\n        if (!ssr)\n            context.helper(builtIn);\n        return builtIn;\n    }\n    // 5. user component (resolve)\n    context.helper(RESOLVE_COMPONENT);\n    context.components.add(tag);\n    return toValidAssetId(tag, `component`);\n}\nfunction buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {\n    const { tag, loc: elementLoc, children } = node;\n    let properties = [];\n    const mergeArgs = [];\n    const runtimeDirectives = [];\n    const hasChildren = children.length > 0;\n    let shouldUseBlock = false;\n    // patchFlag analysis\n    let patchFlag = 0;\n    let hasRef = false;\n    let hasClassBinding = false;\n    let hasStyleBinding = false;\n    let hasHydrationEventBinding = false;\n    let hasDynamicKeys = false;\n    let hasVnodeHook = false;\n    const dynamicPropNames = [];\n    const pushMergeArg = (arg) => {\n        if (properties.length) {\n            mergeArgs.push(createObjectExpression(dedupeProperties(properties), elementLoc));\n            properties = [];\n        }\n        if (arg)\n            mergeArgs.push(arg);\n    };\n    const analyzePatchFlag = ({ key, value }) => {\n        if (isStaticExp(key)) {\n            const name = key.content;\n            const isEventHandler = isOn(name);\n            if (isEventHandler &&\n                (!isComponent || isDynamicComponent) &&\n                // omit the flag for click handlers because hydration gives click\n                // dedicated fast path.\n                name.toLowerCase() !== 'onclick' &&\n                // omit v-model handlers\n                name !== 'onUpdate:modelValue' &&\n                // omit onVnodeXXX hooks\n                !isReservedProp(name)) {\n                hasHydrationEventBinding = true;\n            }\n            if (isEventHandler && isReservedProp(name)) {\n                hasVnodeHook = true;\n            }\n            if (value.type === 20 /* NodeTypes.JS_CACHE_EXPRESSION */ ||\n                ((value.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ ||\n                    value.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */) &&\n                    getConstantType(value, context) > 0)) {\n                // skip if the prop is a cached handler or has constant value\n                return;\n            }\n            if (name === 'ref') {\n                hasRef = true;\n            }\n            else if (name === 'class') {\n                hasClassBinding = true;\n            }\n            else if (name === 'style') {\n                hasStyleBinding = true;\n            }\n            else if (name !== 'key' && !dynamicPropNames.includes(name)) {\n                dynamicPropNames.push(name);\n            }\n            // treat the dynamic class and style binding of the component as dynamic props\n            if (isComponent &&\n                (name === 'class' || name === 'style') &&\n                !dynamicPropNames.includes(name)) {\n                dynamicPropNames.push(name);\n            }\n        }\n        else {\n            hasDynamicKeys = true;\n        }\n    };\n    for (let i = 0; i < props.length; i++) {\n        // static attribute\n        const prop = props[i];\n        if (prop.type === 6 /* NodeTypes.ATTRIBUTE */) {\n            const { loc, name, value } = prop;\n            let isStatic = true;\n            if (name === 'ref') {\n                hasRef = true;\n                if (context.scopes.vFor > 0) {\n                    properties.push(createObjectProperty(createSimpleExpression('ref_for', true), createSimpleExpression('true')));\n                }\n            }\n            // skip is on <component>, or is=\"vue:xxx\"\n            if (name === 'is' &&\n                (isComponentTag(tag) ||\n                    (value && value.content.startsWith('vue:')) ||\n                    (isCompatEnabled(\"COMPILER_IS_ON_ELEMENT\" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */, context)))) {\n                continue;\n            }\n            properties.push(createObjectProperty(createSimpleExpression(name, true, getInnerRange(loc, 0, name.length)), createSimpleExpression(value ? value.content : '', isStatic, value ? value.loc : loc)));\n        }\n        else {\n            // directives\n            const { name, arg, exp, loc } = prop;\n            const isVBind = name === 'bind';\n            const isVOn = name === 'on';\n            // skip v-slot - it is handled by its dedicated transform.\n            if (name === 'slot') {\n                if (!isComponent) {\n                    context.onError(createCompilerError(40 /* ErrorCodes.X_V_SLOT_MISPLACED */, loc));\n                }\n                continue;\n            }\n            // skip v-once/v-memo - they are handled by dedicated transforms.\n            if (name === 'once' || name === 'memo') {\n                continue;\n            }\n            // skip v-is and :is on <component>\n            if (name === 'is' ||\n                (isVBind &&\n                    isStaticArgOf(arg, 'is') &&\n                    (isComponentTag(tag) ||\n                        (isCompatEnabled(\"COMPILER_IS_ON_ELEMENT\" /* CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT */, context))))) {\n                continue;\n            }\n            // skip v-on in SSR compilation\n            if (isVOn && ssr) {\n                continue;\n            }\n            if (\n            // #938: elements with dynamic keys should be forced into blocks\n            (isVBind && isStaticArgOf(arg, 'key')) ||\n                // inline before-update hooks need to force block so that it is invoked\n                // before children\n                (isVOn && hasChildren && isStaticArgOf(arg, 'vue:before-update'))) {\n                shouldUseBlock = true;\n            }\n            if (isVBind && isStaticArgOf(arg, 'ref') && context.scopes.vFor > 0) {\n                properties.push(createObjectProperty(createSimpleExpression('ref_for', true), createSimpleExpression('true')));\n            }\n            // special case for v-bind and v-on with no argument\n            if (!arg && (isVBind || isVOn)) {\n                hasDynamicKeys = true;\n                if (exp) {\n                    if (isVBind) {\n                        // have to merge early for compat build check\n                        pushMergeArg();\n                        {\n                            // 2.x v-bind object order compat\n                            if ((process.env.NODE_ENV !== 'production')) {\n                                const hasOverridableKeys = mergeArgs.some(arg => {\n                                    if (arg.type === 15 /* NodeTypes.JS_OBJECT_EXPRESSION */) {\n                                        return arg.properties.some(({ key }) => {\n                                            if (key.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */ ||\n                                                !key.isStatic) {\n                                                return true;\n                                            }\n                                            return (key.content !== 'class' &&\n                                                key.content !== 'style' &&\n                                                !isOn(key.content));\n                                        });\n                                    }\n                                    else {\n                                        // dynamic expression\n                                        return true;\n                                    }\n                                });\n                                if (hasOverridableKeys) {\n                                    checkCompatEnabled(\"COMPILER_V_BIND_OBJECT_ORDER\" /* CompilerDeprecationTypes.COMPILER_V_BIND_OBJECT_ORDER */, context, loc);\n                                }\n                            }\n                            if (isCompatEnabled(\"COMPILER_V_BIND_OBJECT_ORDER\" /* CompilerDeprecationTypes.COMPILER_V_BIND_OBJECT_ORDER */, context)) {\n                                mergeArgs.unshift(exp);\n                                continue;\n                            }\n                        }\n                        mergeArgs.push(exp);\n                    }\n                    else {\n                        // v-on=\"obj\" -> toHandlers(obj)\n                        pushMergeArg({\n                            type: 14 /* NodeTypes.JS_CALL_EXPRESSION */,\n                            loc,\n                            callee: context.helper(TO_HANDLERS),\n                            arguments: isComponent ? [exp] : [exp, `true`]\n                        });\n                    }\n                }\n                else {\n                    context.onError(createCompilerError(isVBind\n                        ? 34 /* ErrorCodes.X_V_BIND_NO_EXPRESSION */\n                        : 35 /* ErrorCodes.X_V_ON_NO_EXPRESSION */, loc));\n                }\n                continue;\n            }\n            const directiveTransform = context.directiveTransforms[name];\n            if (directiveTransform) {\n                // has built-in directive transform.\n                const { props, needRuntime } = directiveTransform(prop, node, context);\n                !ssr && props.forEach(analyzePatchFlag);\n                if (isVOn && arg && !isStaticExp(arg)) {\n                    pushMergeArg(createObjectExpression(props, elementLoc));\n                }\n                else {\n                    properties.push(...props);\n                }\n                if (needRuntime) {\n                    runtimeDirectives.push(prop);\n                    if (isSymbol(needRuntime)) {\n                        directiveImportMap.set(prop, needRuntime);\n                    }\n                }\n            }\n            else if (!isBuiltInDirective(name)) {\n                // no built-in transform, this is a user custom directive.\n                runtimeDirectives.push(prop);\n                // custom dirs may use beforeUpdate so they need to force blocks\n                // to ensure before-update gets called before children update\n                if (hasChildren) {\n                    shouldUseBlock = true;\n                }\n            }\n        }\n    }\n    let propsExpression = undefined;\n    // has v-bind=\"object\" or v-on=\"object\", wrap with mergeProps\n    if (mergeArgs.length) {\n        // close up any not-yet-merged props\n        pushMergeArg();\n        if (mergeArgs.length > 1) {\n            propsExpression = createCallExpression(context.helper(MERGE_PROPS), mergeArgs, elementLoc);\n        }\n        else {\n            // single v-bind with nothing else - no need for a mergeProps call\n            propsExpression = mergeArgs[0];\n        }\n    }\n    else if (properties.length) {\n        propsExpression = createObjectExpression(dedupeProperties(properties), elementLoc);\n    }\n    // patchFlag analysis\n    if (hasDynamicKeys) {\n        patchFlag |= 16 /* PatchFlags.FULL_PROPS */;\n    }\n    else {\n        if (hasClassBinding && !isComponent) {\n            patchFlag |= 2 /* PatchFlags.CLASS */;\n        }\n        if (hasStyleBinding && !isComponent) {\n            patchFlag |= 4 /* PatchFlags.STYLE */;\n        }\n        if (dynamicPropNames.length) {\n            patchFlag |= 8 /* PatchFlags.PROPS */;\n        }\n        if (hasHydrationEventBinding) {\n            patchFlag |= 32 /* PatchFlags.HYDRATE_EVENTS */;\n        }\n    }\n    if (!shouldUseBlock &&\n        (patchFlag === 0 || patchFlag === 32 /* PatchFlags.HYDRATE_EVENTS */) &&\n        (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {\n        patchFlag |= 512 /* PatchFlags.NEED_PATCH */;\n    }\n    // pre-normalize props, SSR is skipped for now\n    if (!context.inSSR && propsExpression) {\n        switch (propsExpression.type) {\n            case 15 /* NodeTypes.JS_OBJECT_EXPRESSION */:\n                // means that there is no v-bind,\n                // but still need to deal with dynamic key binding\n                let classKeyIndex = -1;\n                let styleKeyIndex = -1;\n                let hasDynamicKey = false;\n                for (let i = 0; i < propsExpression.properties.length; i++) {\n                    const key = propsExpression.properties[i].key;\n                    if (isStaticExp(key)) {\n                        if (key.content === 'class') {\n                            classKeyIndex = i;\n                        }\n                        else if (key.content === 'style') {\n                            styleKeyIndex = i;\n                        }\n                    }\n                    else if (!key.isHandlerKey) {\n                        hasDynamicKey = true;\n                    }\n                }\n                const classProp = propsExpression.properties[classKeyIndex];\n                const styleProp = propsExpression.properties[styleKeyIndex];\n                // no dynamic key\n                if (!hasDynamicKey) {\n                    if (classProp && !isStaticExp(classProp.value)) {\n                        classProp.value = createCallExpression(context.helper(NORMALIZE_CLASS), [classProp.value]);\n                    }\n                    if (styleProp &&\n                        // the static style is compiled into an object,\n                        // so use `hasStyleBinding` to ensure that it is a dynamic style binding\n                        (hasStyleBinding ||\n                            (styleProp.value.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ &&\n                                styleProp.value.content.trim()[0] === `[`) ||\n                            // v-bind:style and style both exist,\n                            // v-bind:style with static literal object\n                            styleProp.value.type === 17 /* NodeTypes.JS_ARRAY_EXPRESSION */)) {\n                        styleProp.value = createCallExpression(context.helper(NORMALIZE_STYLE), [styleProp.value]);\n                    }\n                }\n                else {\n                    // dynamic key binding, wrap with `normalizeProps`\n                    propsExpression = createCallExpression(context.helper(NORMALIZE_PROPS), [propsExpression]);\n                }\n                break;\n            case 14 /* NodeTypes.JS_CALL_EXPRESSION */:\n                // mergeProps call, do nothing\n                break;\n            default:\n                // single v-bind\n                propsExpression = createCallExpression(context.helper(NORMALIZE_PROPS), [\n                    createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [\n                        propsExpression\n                    ])\n                ]);\n                break;\n        }\n    }\n    return {\n        props: propsExpression,\n        directives: runtimeDirectives,\n        patchFlag,\n        dynamicPropNames,\n        shouldUseBlock\n    };\n}\n// Dedupe props in an object literal.\n// Literal duplicated attributes would have been warned during the parse phase,\n// however, it's possible to encounter duplicated `onXXX` handlers with different\n// modifiers. We also need to merge static and dynamic class / style attributes.\n// - onXXX handlers / style: merge into array\n// - class: merge into single expression with concatenation\nfunction dedupeProperties(properties) {\n    const knownProps = new Map();\n    const deduped = [];\n    for (let i = 0; i < properties.length; i++) {\n        const prop = properties[i];\n        // dynamic keys are always allowed\n        if (prop.key.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */ || !prop.key.isStatic) {\n            deduped.push(prop);\n            continue;\n        }\n        const name = prop.key.content;\n        const existing = knownProps.get(name);\n        if (existing) {\n            if (name === 'style' || name === 'class' || isOn(name)) {\n                mergeAsArray(existing, prop);\n            }\n            // unexpected duplicate, should have emitted error during parse\n        }\n        else {\n            knownProps.set(name, prop);\n            deduped.push(prop);\n        }\n    }\n    return deduped;\n}\nfunction mergeAsArray(existing, incoming) {\n    if (existing.value.type === 17 /* NodeTypes.JS_ARRAY_EXPRESSION */) {\n        existing.value.elements.push(incoming.value);\n    }\n    else {\n        existing.value = createArrayExpression([existing.value, incoming.value], existing.loc);\n    }\n}\nfunction buildDirectiveArgs(dir, context) {\n    const dirArgs = [];\n    const runtime = directiveImportMap.get(dir);\n    if (runtime) {\n        // built-in directive with runtime\n        dirArgs.push(context.helperString(runtime));\n    }\n    else {\n        {\n            // inject statement for resolving directive\n            context.helper(RESOLVE_DIRECTIVE);\n            context.directives.add(dir.name);\n            dirArgs.push(toValidAssetId(dir.name, `directive`));\n        }\n    }\n    const { loc } = dir;\n    if (dir.exp)\n        dirArgs.push(dir.exp);\n    if (dir.arg) {\n        if (!dir.exp) {\n            dirArgs.push(`void 0`);\n        }\n        dirArgs.push(dir.arg);\n    }\n    if (Object.keys(dir.modifiers).length) {\n        if (!dir.arg) {\n            if (!dir.exp) {\n                dirArgs.push(`void 0`);\n            }\n            dirArgs.push(`void 0`);\n        }\n        const trueExpression = createSimpleExpression(`true`, false, loc);\n        dirArgs.push(createObjectExpression(dir.modifiers.map(modifier => createObjectProperty(modifier, trueExpression)), loc));\n    }\n    return createArrayExpression(dirArgs, dir.loc);\n}\nfunction stringifyDynamicPropNames(props) {\n    let propsNamesString = `[`;\n    for (let i = 0, l = props.length; i < l; i++) {\n        propsNamesString += JSON.stringify(props[i]);\n        if (i < l - 1)\n            propsNamesString += ', ';\n    }\n    return propsNamesString + `]`;\n}\nfunction isComponentTag(tag) {\n    return tag === 'component' || tag === 'Component';\n}\n\n(process.env.NODE_ENV !== 'production')\n    ? Object.freeze({})\n    : {};\n(process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];\nconst cacheStringFunction = (fn) => {\n    const cache = Object.create(null);\n    return ((str) => {\n        const hit = cache[str];\n        return hit || (cache[str] = fn(str));\n    });\n};\nconst camelizeRE = /-(\\w)/g;\n/**\n * @private\n */\nconst camelize = cacheStringFunction((str) => {\n    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\n});\n\nconst transformSlotOutlet = (node, context) => {\n    if (isSlotOutlet(node)) {\n        const { children, loc } = node;\n        const { slotName, slotProps } = processSlotOutlet(node, context);\n        const slotArgs = [\n            context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,\n            slotName,\n            '{}',\n            'undefined',\n            'true'\n        ];\n        let expectedLen = 2;\n        if (slotProps) {\n            slotArgs[2] = slotProps;\n            expectedLen = 3;\n        }\n        if (children.length) {\n            slotArgs[3] = createFunctionExpression([], children, false, false, loc);\n            expectedLen = 4;\n        }\n        if (context.scopeId && !context.slotted) {\n            expectedLen = 5;\n        }\n        slotArgs.splice(expectedLen); // remove unused arguments\n        node.codegenNode = createCallExpression(context.helper(RENDER_SLOT), slotArgs, loc);\n    }\n};\nfunction processSlotOutlet(node, context) {\n    let slotName = `\"default\"`;\n    let slotProps = undefined;\n    const nonNameProps = [];\n    for (let i = 0; i < node.props.length; i++) {\n        const p = node.props[i];\n        if (p.type === 6 /* NodeTypes.ATTRIBUTE */) {\n            if (p.value) {\n                if (p.name === 'name') {\n                    slotName = JSON.stringify(p.value.content);\n                }\n                else {\n                    p.name = camelize(p.name);\n                    nonNameProps.push(p);\n                }\n            }\n        }\n        else {\n            if (p.name === 'bind' && isStaticArgOf(p.arg, 'name')) {\n                if (p.exp)\n                    slotName = p.exp;\n            }\n            else {\n                if (p.name === 'bind' && p.arg && isStaticExp(p.arg)) {\n                    p.arg.content = camelize(p.arg.content);\n                }\n                nonNameProps.push(p);\n            }\n        }\n    }\n    if (nonNameProps.length > 0) {\n        const { props, directives } = buildProps(node, context, nonNameProps, false, false);\n        slotProps = props;\n        if (directives.length) {\n            context.onError(createCompilerError(36 /* ErrorCodes.X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */, directives[0].loc));\n        }\n    }\n    return {\n        slotName,\n        slotProps\n    };\n}\n\nconst fnExpRE = /^\\s*([\\w$_]+|(async\\s*)?\\([^)]*?\\))\\s*(:[^=]+)?=>|^\\s*(async\\s+)?function(?:\\s+[\\w$]+)?\\s*\\(/;\nconst transformOn = (dir, node, context, augmentor) => {\n    const { loc, modifiers, arg } = dir;\n    if (!dir.exp && !modifiers.length) {\n        context.onError(createCompilerError(35 /* ErrorCodes.X_V_ON_NO_EXPRESSION */, loc));\n    }\n    let eventName;\n    if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n        if (arg.isStatic) {\n            let rawName = arg.content;\n            // TODO deprecate @vnodeXXX usage\n            if (rawName.startsWith('vue:')) {\n                rawName = `vnode-${rawName.slice(4)}`;\n            }\n            const eventString = node.tagType !== 0 /* ElementTypes.ELEMENT */ ||\n                rawName.startsWith('vnode') ||\n                !/[A-Z]/.test(rawName)\n                ? // for non-element and vnode lifecycle event listeners, auto convert\n                    // it to camelCase. See issue #2249\n                    toHandlerKey(camelize$1(rawName))\n                : // preserve case for plain element listeners that have uppercase\n                    // letters, as these may be custom elements' custom events\n                    `on:${rawName}`;\n            eventName = createSimpleExpression(eventString, true, arg.loc);\n        }\n        else {\n            // #2388\n            eventName = createCompoundExpression([\n                `${context.helperString(TO_HANDLER_KEY)}(`,\n                arg,\n                `)`\n            ]);\n        }\n    }\n    else {\n        // already a compound expression.\n        eventName = arg;\n        eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);\n        eventName.children.push(`)`);\n    }\n    // handler processing\n    let exp = dir.exp;\n    if (exp && !exp.content.trim()) {\n        exp = undefined;\n    }\n    let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;\n    if (exp) {\n        const isMemberExp = isMemberExpression(exp.content);\n        const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content));\n        const hasMultipleStatements = exp.content.includes(`;`);\n        if ((process.env.NODE_ENV !== 'production') && true) {\n            validateBrowserExpression(exp, context, false, hasMultipleStatements);\n        }\n        if (isInlineStatement || (shouldCache && isMemberExp)) {\n            // wrap inline statement in a function expression\n            exp = createCompoundExpression([\n                `${isInlineStatement\n                    ? `$event`\n                    : `${``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,\n                exp,\n                hasMultipleStatements ? `}` : `)`\n            ]);\n        }\n    }\n    let ret = {\n        props: [\n            createObjectProperty(eventName, exp || createSimpleExpression(`() => {}`, false, loc))\n        ]\n    };\n    // apply extended compiler augmentor\n    if (augmentor) {\n        ret = augmentor(ret);\n    }\n    if (shouldCache) {\n        // cache handlers so that it's always the same handler being passed down.\n        // this avoids unnecessary re-renders when users use inline handlers on\n        // components.\n        ret.props[0].value = context.cache(ret.props[0].value);\n    }\n    // mark the key as handler for props normalization check\n    ret.props.forEach(p => (p.key.isHandlerKey = true));\n    return ret;\n};\n\n// v-bind without arg is handled directly in ./transformElements.ts due to it affecting\n// codegen for the entire props object. This transform here is only for v-bind\n// *with* args.\nconst transformBind = (dir, _node, context) => {\n    const { exp, modifiers, loc } = dir;\n    const arg = dir.arg;\n    if (arg.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n        arg.children.unshift(`(`);\n        arg.children.push(`) || \"\"`);\n    }\n    else if (!arg.isStatic) {\n        arg.content = `${arg.content} || \"\"`;\n    }\n    // .sync is replaced by v-model:arg\n    if (modifiers.includes('camel')) {\n        if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n            if (arg.isStatic) {\n                arg.content = camelize$1(arg.content);\n            }\n            else {\n                arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;\n            }\n        }\n        else {\n            arg.children.unshift(`${context.helperString(CAMELIZE)}(`);\n            arg.children.push(`)`);\n        }\n    }\n    if (!context.inSSR) {\n        if (modifiers.includes('prop')) {\n            injectPrefix(arg, '.');\n        }\n        if (modifiers.includes('attr')) {\n            injectPrefix(arg, '^');\n        }\n    }\n    if (!exp ||\n        (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && !exp.content.trim())) {\n        context.onError(createCompilerError(34 /* ErrorCodes.X_V_BIND_NO_EXPRESSION */, loc));\n        return {\n            props: [createObjectProperty(arg, createSimpleExpression('', true, loc))]\n        };\n    }\n    return {\n        props: [createObjectProperty(arg, exp)]\n    };\n};\nconst injectPrefix = (arg, prefix) => {\n    if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n        if (arg.isStatic) {\n            arg.content = prefix + arg.content;\n        }\n        else {\n            arg.content = `\\`${prefix}\\${${arg.content}}\\``;\n        }\n    }\n    else {\n        arg.children.unshift(`'${prefix}' + (`);\n        arg.children.push(`)`);\n    }\n};\n\n// Merge adjacent text nodes and expressions into a single expression\n// e.g. <div>abc {{ d }} {{ e }}</div> should have a single expression node as child.\nconst transformText = (node, context) => {\n    if (node.type === 0 /* NodeTypes.ROOT */ ||\n        node.type === 1 /* NodeTypes.ELEMENT */ ||\n        node.type === 11 /* NodeTypes.FOR */ ||\n        node.type === 10 /* NodeTypes.IF_BRANCH */) {\n        // perform the transform on node exit so that all expressions have already\n        // been processed.\n        return () => {\n            const children = node.children;\n            let currentContainer = undefined;\n            let hasText = false;\n            for (let i = 0; i < children.length; i++) {\n                const child = children[i];\n                if (isText(child)) {\n                    hasText = true;\n                    for (let j = i + 1; j < children.length; j++) {\n                        const next = children[j];\n                        if (isText(next)) {\n                            if (!currentContainer) {\n                                currentContainer = children[i] = createCompoundExpression([child], child.loc);\n                            }\n                            // merge adjacent text node into current\n                            currentContainer.children.push(` + `, next);\n                            children.splice(j, 1);\n                            j--;\n                        }\n                        else {\n                            currentContainer = undefined;\n                            break;\n                        }\n                    }\n                }\n            }\n            if (!hasText ||\n                // if this is a plain element with a single text child, leave it\n                // as-is since the runtime has dedicated fast path for this by directly\n                // setting textContent of the element.\n                // for component root it's always normalized anyway.\n                (children.length === 1 &&\n                    (node.type === 0 /* NodeTypes.ROOT */ ||\n                        (node.type === 1 /* NodeTypes.ELEMENT */ &&\n                            node.tagType === 0 /* ElementTypes.ELEMENT */ &&\n                            // #3756\n                            // custom directives can potentially add DOM elements arbitrarily,\n                            // we need to avoid setting textContent of the element at runtime\n                            // to avoid accidentally overwriting the DOM elements added\n                            // by the user through custom directives.\n                            !node.props.find(p => p.type === 7 /* NodeTypes.DIRECTIVE */ &&\n                                !context.directiveTransforms[p.name]) &&\n                            // in compat mode, <template> tags with no special directives\n                            // will be rendered as a fragment so its children must be\n                            // converted into vnodes.\n                            !(node.tag === 'template'))))) {\n                return;\n            }\n            // pre-convert text nodes into createTextVNode(text) calls to avoid\n            // runtime normalization.\n            for (let i = 0; i < children.length; i++) {\n                const child = children[i];\n                if (isText(child) || child.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */) {\n                    const callArgs = [];\n                    // createTextVNode defaults to single whitespace, so if it is a\n                    // single space the code could be an empty call to save bytes.\n                    if (child.type !== 2 /* NodeTypes.TEXT */ || child.content !== ' ') {\n                        callArgs.push(child);\n                    }\n                    // mark dynamic text with flag so it gets patched inside a block\n                    if (!context.ssr &&\n                        getConstantType(child, context) === 0 /* ConstantTypes.NOT_CONSTANT */) {\n                        callArgs.push(1 /* PatchFlags.TEXT */ +\n                            ((process.env.NODE_ENV !== 'production') ? ` /* ${PatchFlagNames[1 /* PatchFlags.TEXT */]} */` : ``));\n                    }\n                    children[i] = {\n                        type: 12 /* NodeTypes.TEXT_CALL */,\n                        content: child,\n                        loc: child.loc,\n                        codegenNode: createCallExpression(context.helper(CREATE_TEXT), callArgs)\n                    };\n                }\n            }\n        };\n    }\n};\n\nconst seen = new WeakSet();\nconst transformOnce = (node, context) => {\n    if (node.type === 1 /* NodeTypes.ELEMENT */ && findDir(node, 'once', true)) {\n        if (seen.has(node) || context.inVOnce) {\n            return;\n        }\n        seen.add(node);\n        context.inVOnce = true;\n        context.helper(SET_BLOCK_TRACKING);\n        return () => {\n            context.inVOnce = false;\n            const cur = context.currentNode;\n            if (cur.codegenNode) {\n                cur.codegenNode = context.cache(cur.codegenNode, true /* isVNode */);\n            }\n        };\n    }\n};\n\nconst transformModel = (dir, node, context) => {\n    const { exp, arg } = dir;\n    if (!exp) {\n        context.onError(createCompilerError(41 /* ErrorCodes.X_V_MODEL_NO_EXPRESSION */, dir.loc));\n        return createTransformProps();\n    }\n    const rawExp = exp.loc.source;\n    const expString = exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ ? exp.content : rawExp;\n    // im SFC <script setup> inline mode, the exp may have been transformed into\n    // _unref(exp)\n    const bindingType = context.bindingMetadata[rawExp];\n    // check props\n    if (bindingType === \"props\" /* BindingTypes.PROPS */ ||\n        bindingType === \"props-aliased\" /* BindingTypes.PROPS_ALIASED */) {\n        context.onError(createCompilerError(44 /* ErrorCodes.X_V_MODEL_ON_PROPS */, exp.loc));\n        return createTransformProps();\n    }\n    const maybeRef = !true  ;\n    if (!expString.trim() ||\n        (!isMemberExpression(expString) && !maybeRef)) {\n        context.onError(createCompilerError(42 /* ErrorCodes.X_V_MODEL_MALFORMED_EXPRESSION */, exp.loc));\n        return createTransformProps();\n    }\n    const propName = arg ? arg : createSimpleExpression('modelValue', true);\n    const eventName = arg\n        ? isStaticExp(arg)\n            ? `onUpdate:${arg.content}`\n            : createCompoundExpression(['\"onUpdate:\" + ', arg])\n        : `onUpdate:modelValue`;\n    let assignmentExp;\n    const eventArg = context.isTS ? `($event: any)` : `$event`;\n    {\n        assignmentExp = createCompoundExpression([\n            `${eventArg} => ((`,\n            exp,\n            `) = $event)`\n        ]);\n    }\n    const props = [\n        // modelValue: foo\n        createObjectProperty(propName, dir.exp),\n        // \"onUpdate:modelValue\": $event => (foo = $event)\n        createObjectProperty(eventName, assignmentExp)\n    ];\n    // modelModifiers: { foo: true, \"bar-baz\": true }\n    if (dir.modifiers.length && node.tagType === 1 /* ElementTypes.COMPONENT */) {\n        const modifiers = dir.modifiers\n            .map(m => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`)\n            .join(`, `);\n        const modifiersKey = arg\n            ? isStaticExp(arg)\n                ? `${arg.content}Modifiers`\n                : createCompoundExpression([arg, ' + \"Modifiers\"'])\n            : `modelModifiers`;\n        props.push(createObjectProperty(modifiersKey, createSimpleExpression(`{ ${modifiers} }`, false, dir.loc, 2 /* ConstantTypes.CAN_HOIST */)));\n    }\n    return createTransformProps(props);\n};\nfunction createTransformProps(props = []) {\n    return { props };\n}\n\nconst validDivisionCharRE = /[\\w).+\\-_$\\]]/;\nconst transformFilter = (node, context) => {\n    if (!isCompatEnabled(\"COMPILER_FILTER\" /* CompilerDeprecationTypes.COMPILER_FILTERS */, context)) {\n        return;\n    }\n    if (node.type === 5 /* NodeTypes.INTERPOLATION */) {\n        // filter rewrite is applied before expression transform so only\n        // simple expressions are possible at this stage\n        rewriteFilter(node.content, context);\n    }\n    if (node.type === 1 /* NodeTypes.ELEMENT */) {\n        node.props.forEach((prop) => {\n            if (prop.type === 7 /* NodeTypes.DIRECTIVE */ &&\n                prop.name !== 'for' &&\n                prop.exp) {\n                rewriteFilter(prop.exp, context);\n            }\n        });\n    }\n};\nfunction rewriteFilter(node, context) {\n    if (node.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n        parseFilter(node, context);\n    }\n    else {\n        for (let i = 0; i < node.children.length; i++) {\n            const child = node.children[i];\n            if (typeof child !== 'object')\n                continue;\n            if (child.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {\n                parseFilter(child, context);\n            }\n            else if (child.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */) {\n                rewriteFilter(node, context);\n            }\n            else if (child.type === 5 /* NodeTypes.INTERPOLATION */) {\n                rewriteFilter(child.content, context);\n            }\n        }\n    }\n}\nfunction parseFilter(node, context) {\n    const exp = node.content;\n    let inSingle = false;\n    let inDouble = false;\n    let inTemplateString = false;\n    let inRegex = false;\n    let curly = 0;\n    let square = 0;\n    let paren = 0;\n    let lastFilterIndex = 0;\n    let c, prev, i, expression, filters = [];\n    for (i = 0; i < exp.length; i++) {\n        prev = c;\n        c = exp.charCodeAt(i);\n        if (inSingle) {\n            if (c === 0x27 && prev !== 0x5c)\n                inSingle = false;\n        }\n        else if (inDouble) {\n            if (c === 0x22 && prev !== 0x5c)\n                inDouble = false;\n        }\n        else if (inTemplateString) {\n            if (c === 0x60 && prev !== 0x5c)\n                inTemplateString = false;\n        }\n        else if (inRegex) {\n            if (c === 0x2f && prev !== 0x5c)\n                inRegex = false;\n        }\n        else if (c === 0x7c && // pipe\n            exp.charCodeAt(i + 1) !== 0x7c &&\n            exp.charCodeAt(i - 1) !== 0x7c &&\n            !curly &&\n            !square &&\n            !paren) {\n            if (expression === undefined) {\n                // first filter, end of expression\n                lastFilterIndex = i + 1;\n                expression = exp.slice(0, i).trim();\n            }\n            else {\n                pushFilter();\n            }\n        }\n        else {\n            switch (c) {\n                case 0x22:\n                    inDouble = true;\n                    break; // \"\n                case 0x27:\n                    inSingle = true;\n                    break; // '\n                case 0x60:\n                    inTemplateString = true;\n                    break; // `\n                case 0x28:\n                    paren++;\n                    break; // (\n                case 0x29:\n                    paren--;\n                    break; // )\n                case 0x5b:\n                    square++;\n                    break; // [\n                case 0x5d:\n                    square--;\n                    break; // ]\n                case 0x7b:\n                    curly++;\n                    break; // {\n                case 0x7d:\n                    curly--;\n                    break; // }\n            }\n            if (c === 0x2f) {\n                // /\n                let j = i - 1;\n                let p;\n                // find first non-whitespace prev char\n                for (; j >= 0; j--) {\n                    p = exp.charAt(j);\n                    if (p !== ' ')\n                        break;\n                }\n                if (!p || !validDivisionCharRE.test(p)) {\n                    inRegex = true;\n                }\n            }\n        }\n    }\n    if (expression === undefined) {\n        expression = exp.slice(0, i).trim();\n    }\n    else if (lastFilterIndex !== 0) {\n        pushFilter();\n    }\n    function pushFilter() {\n        filters.push(exp.slice(lastFilterIndex, i).trim());\n        lastFilterIndex = i + 1;\n    }\n    if (filters.length) {\n        (process.env.NODE_ENV !== 'production') &&\n            warnDeprecation(\"COMPILER_FILTER\" /* CompilerDeprecationTypes.COMPILER_FILTERS */, context, node.loc);\n        for (i = 0; i < filters.length; i++) {\n            expression = wrapFilter(expression, filters[i], context);\n        }\n        node.content = expression;\n    }\n}\nfunction wrapFilter(exp, filter, context) {\n    context.helper(RESOLVE_FILTER);\n    const i = filter.indexOf('(');\n    if (i < 0) {\n        context.filters.add(filter);\n        return `${toValidAssetId(filter, 'filter')}(${exp})`;\n    }\n    else {\n        const name = filter.slice(0, i);\n        const args = filter.slice(i + 1);\n        context.filters.add(name);\n        return `${toValidAssetId(name, 'filter')}(${exp}${args !== ')' ? ',' + args : args}`;\n    }\n}\n\nconst seen$1 = new WeakSet();\nconst transformMemo = (node, context) => {\n    if (node.type === 1 /* NodeTypes.ELEMENT */) {\n        const dir = findDir(node, 'memo');\n        if (!dir || seen$1.has(node)) {\n            return;\n        }\n        seen$1.add(node);\n        return () => {\n            const codegenNode = node.codegenNode ||\n                context.currentNode.codegenNode;\n            if (codegenNode && codegenNode.type === 13 /* NodeTypes.VNODE_CALL */) {\n                // non-component sub tree should be turned into a block\n                if (node.tagType !== 1 /* ElementTypes.COMPONENT */) {\n                    makeBlock(codegenNode, context);\n                }\n                node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [\n                    dir.exp,\n                    createFunctionExpression(undefined, codegenNode),\n                    `_cache`,\n                    String(context.cached++)\n                ]);\n            }\n        };\n    }\n};\n\nfunction getBaseTransformPreset(prefixIdentifiers) {\n    return [\n        [\n            transformOnce,\n            transformIf,\n            transformMemo,\n            transformFor,\n            ...([transformFilter] ),\n            ...((process.env.NODE_ENV !== 'production')\n                    ? [transformExpression]\n                    : []),\n            transformSlotOutlet,\n            transformElement,\n            trackSlotScopes,\n            transformText\n        ],\n        {\n            on: transformOn,\n            bind: transformBind,\n            model: transformModel\n        }\n    ];\n}\n// we name it `baseCompile` so that higher order compilers like\n// @vue/compiler-dom can export `compile` while re-exporting everything else.\nfunction baseCompile(template, options = {}) {\n    const onError = options.onError || defaultOnError;\n    const isModuleMode = options.mode === 'module';\n    /* istanbul ignore if */\n    {\n        if (options.prefixIdentifiers === true) {\n            onError(createCompilerError(47 /* ErrorCodes.X_PREFIX_ID_NOT_SUPPORTED */));\n        }\n        else if (isModuleMode) {\n            onError(createCompilerError(48 /* ErrorCodes.X_MODULE_MODE_NOT_SUPPORTED */));\n        }\n    }\n    const prefixIdentifiers = !true ;\n    if (options.cacheHandlers) {\n        onError(createCompilerError(49 /* ErrorCodes.X_CACHE_HANDLER_NOT_SUPPORTED */));\n    }\n    if (options.scopeId && !isModuleMode) {\n        onError(createCompilerError(50 /* ErrorCodes.X_SCOPE_ID_NOT_SUPPORTED */));\n    }\n    const ast = isString(template) ? baseParse(template, options) : template;\n    const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();\n    transform(ast, extend({}, options, {\n        prefixIdentifiers,\n        nodeTransforms: [\n            ...nodeTransforms,\n            ...(options.nodeTransforms || []) // user transforms\n        ],\n        directiveTransforms: extend({}, directiveTransforms, options.directiveTransforms || {} // user transforms\n        )\n    }));\n    return generate(ast, extend({}, options, {\n        prefixIdentifiers\n    }));\n}\n\nconst noopDirectiveTransform = () => ({ props: [] });\n\nexport { BASE_TRANSITION, CAMELIZE, CAPITALIZE, CREATE_BLOCK, CREATE_COMMENT, CREATE_ELEMENT_BLOCK, CREATE_ELEMENT_VNODE, CREATE_SLOTS, CREATE_STATIC, CREATE_TEXT, CREATE_VNODE, FRAGMENT, GUARD_REACTIVE_PROPS, IS_MEMO_SAME, IS_REF, KEEP_ALIVE, MERGE_PROPS, NORMALIZE_CLASS, NORMALIZE_PROPS, NORMALIZE_STYLE, OPEN_BLOCK, POP_SCOPE_ID, PUSH_SCOPE_ID, RENDER_LIST, RENDER_SLOT, RESOLVE_COMPONENT, RESOLVE_DIRECTIVE, RESOLVE_DYNAMIC_COMPONENT, RESOLVE_FILTER, SET_BLOCK_TRACKING, SUSPENSE, TELEPORT, TO_DISPLAY_STRING, TO_HANDLERS, TO_HANDLER_KEY, UNREF, WITH_CTX, WITH_DIRECTIVES, WITH_MEMO, advancePositionWithClone, advancePositionWithMutation, assert, baseCompile, baseParse, buildDirectiveArgs, buildProps, buildSlots, checkCompatEnabled, createArrayExpression, createAssignmentExpression, createBlockStatement, createCacheExpression, createCallExpression, createCompilerError, createCompoundExpression, createConditionalExpression, createForLoopParams, createFunctionExpression, createIfStatement, createInterpolation, createObjectExpression, createObjectProperty, createReturnStatement, createRoot, createSequenceExpression, createSimpleExpression, createStructuralDirectiveTransform, createTemplateLiteral, createTransformContext, createVNodeCall, extractIdentifiers, findDir, findProp, generate, getBaseTransformPreset, getConstantType, getInnerRange, getMemoedVNodeCall, getVNodeBlockHelper, getVNodeHelper, hasDynamicKeyVBind, hasScopeRef, helperNameMap, injectProp, isBuiltInType, isCoreComponent, isFunctionType, isInDestructureAssignment, isMemberExpression, isMemberExpressionBrowser, isMemberExpressionNode, isReferencedIdentifier, isSimpleIdentifier, isSlotOutlet, isStaticArgOf, isStaticExp, isStaticProperty, isStaticPropertyKey, isTemplateNode, isText, isVSlot, locStub, makeBlock, noopDirectiveTransform, processExpression, processFor, processIf, processSlotOutlet, registerRuntimeHelpers, resolveComponentType, stringifyExpression, toValidAssetId, trackSlotScopes, trackVForSlotScopes, transform, transformBind, transformElement, transformExpression, transformModel, transformOn, traverseNode, walkBlockDeclarations, walkFunctionParams, walkIdentifiers, warnDeprecation };\n","import { registerRuntimeHelpers, isBuiltInType, createSimpleExpression, createCompilerError, createObjectProperty, getConstantType, createCallExpression, TO_DISPLAY_STRING, transformModel as transformModel$1, findProp, hasDynamicKeyVBind, transformOn as transformOn$1, createCompoundExpression, isStaticExp, checkCompatEnabled, noopDirectiveTransform, baseCompile, baseParse } from '@vue/compiler-core';\nexport * from '@vue/compiler-core';\nimport { isVoidTag, isHTMLTag, isSVGTag, makeMap, parseStringStyle, capitalize, extend } from '@vue/shared';\n\nconst V_MODEL_RADIO = Symbol((process.env.NODE_ENV !== 'production') ? `vModelRadio` : ``);\nconst V_MODEL_CHECKBOX = Symbol((process.env.NODE_ENV !== 'production') ? `vModelCheckbox` : ``);\nconst V_MODEL_TEXT = Symbol((process.env.NODE_ENV !== 'production') ? `vModelText` : ``);\nconst V_MODEL_SELECT = Symbol((process.env.NODE_ENV !== 'production') ? `vModelSelect` : ``);\nconst V_MODEL_DYNAMIC = Symbol((process.env.NODE_ENV !== 'production') ? `vModelDynamic` : ``);\nconst V_ON_WITH_MODIFIERS = Symbol((process.env.NODE_ENV !== 'production') ? `vOnModifiersGuard` : ``);\nconst V_ON_WITH_KEYS = Symbol((process.env.NODE_ENV !== 'production') ? `vOnKeysGuard` : ``);\nconst V_SHOW = Symbol((process.env.NODE_ENV !== 'production') ? `vShow` : ``);\nconst TRANSITION = Symbol((process.env.NODE_ENV !== 'production') ? `Transition` : ``);\nconst TRANSITION_GROUP = Symbol((process.env.NODE_ENV !== 'production') ? `TransitionGroup` : ``);\nregisterRuntimeHelpers({\n    [V_MODEL_RADIO]: `vModelRadio`,\n    [V_MODEL_CHECKBOX]: `vModelCheckbox`,\n    [V_MODEL_TEXT]: `vModelText`,\n    [V_MODEL_SELECT]: `vModelSelect`,\n    [V_MODEL_DYNAMIC]: `vModelDynamic`,\n    [V_ON_WITH_MODIFIERS]: `withModifiers`,\n    [V_ON_WITH_KEYS]: `withKeys`,\n    [V_SHOW]: `vShow`,\n    [TRANSITION]: `Transition`,\n    [TRANSITION_GROUP]: `TransitionGroup`\n});\n\n/* eslint-disable no-restricted-globals */\nlet decoder;\nfunction decodeHtmlBrowser(raw, asAttr = false) {\n    if (!decoder) {\n        decoder = document.createElement('div');\n    }\n    if (asAttr) {\n        decoder.innerHTML = `<div foo=\"${raw.replace(/\"/g, '&quot;')}\">`;\n        return decoder.children[0].getAttribute('foo');\n    }\n    else {\n        decoder.innerHTML = raw;\n        return decoder.textContent;\n    }\n}\n\nconst isRawTextContainer = /*#__PURE__*/ makeMap('style,iframe,script,noscript', true);\nconst parserOptions = {\n    isVoidTag,\n    isNativeTag: tag => isHTMLTag(tag) || isSVGTag(tag),\n    isPreTag: tag => tag === 'pre',\n    decodeEntities: decodeHtmlBrowser ,\n    isBuiltInComponent: (tag) => {\n        if (isBuiltInType(tag, `Transition`)) {\n            return TRANSITION;\n        }\n        else if (isBuiltInType(tag, `TransitionGroup`)) {\n            return TRANSITION_GROUP;\n        }\n    },\n    // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher\n    getNamespace(tag, parent) {\n        let ns = parent ? parent.ns : 0 /* DOMNamespaces.HTML */;\n        if (parent && ns === 2 /* DOMNamespaces.MATH_ML */) {\n            if (parent.tag === 'annotation-xml') {\n                if (tag === 'svg') {\n                    return 1 /* DOMNamespaces.SVG */;\n                }\n                if (parent.props.some(a => a.type === 6 /* NodeTypes.ATTRIBUTE */ &&\n                    a.name === 'encoding' &&\n                    a.value != null &&\n                    (a.value.content === 'text/html' ||\n                        a.value.content === 'application/xhtml+xml'))) {\n                    ns = 0 /* DOMNamespaces.HTML */;\n                }\n            }\n            else if (/^m(?:[ions]|text)$/.test(parent.tag) &&\n                tag !== 'mglyph' &&\n                tag !== 'malignmark') {\n                ns = 0 /* DOMNamespaces.HTML */;\n            }\n        }\n        else if (parent && ns === 1 /* DOMNamespaces.SVG */) {\n            if (parent.tag === 'foreignObject' ||\n                parent.tag === 'desc' ||\n                parent.tag === 'title') {\n                ns = 0 /* DOMNamespaces.HTML */;\n            }\n        }\n        if (ns === 0 /* DOMNamespaces.HTML */) {\n            if (tag === 'svg') {\n                return 1 /* DOMNamespaces.SVG */;\n            }\n            if (tag === 'math') {\n                return 2 /* DOMNamespaces.MATH_ML */;\n            }\n        }\n        return ns;\n    },\n    // https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments\n    getTextMode({ tag, ns }) {\n        if (ns === 0 /* DOMNamespaces.HTML */) {\n            if (tag === 'textarea' || tag === 'title') {\n                return 1 /* TextModes.RCDATA */;\n            }\n            if (isRawTextContainer(tag)) {\n                return 2 /* TextModes.RAWTEXT */;\n            }\n        }\n        return 0 /* TextModes.DATA */;\n    }\n};\n\n// Parse inline CSS strings for static style attributes into an object.\n// This is a NodeTransform since it works on the static `style` attribute and\n// converts it into a dynamic equivalent:\n// style=\"color: red\" -> :style='{ \"color\": \"red\" }'\n// It is then processed by `transformElement` and included in the generated\n// props.\nconst transformStyle = node => {\n    if (node.type === 1 /* NodeTypes.ELEMENT */) {\n        node.props.forEach((p, i) => {\n            if (p.type === 6 /* NodeTypes.ATTRIBUTE */ && p.name === 'style' && p.value) {\n                // replace p with an expression node\n                node.props[i] = {\n                    type: 7 /* NodeTypes.DIRECTIVE */,\n                    name: `bind`,\n                    arg: createSimpleExpression(`style`, true, p.loc),\n                    exp: parseInlineCSS(p.value.content, p.loc),\n                    modifiers: [],\n                    loc: p.loc\n                };\n            }\n        });\n    }\n};\nconst parseInlineCSS = (cssText, loc) => {\n    const normalized = parseStringStyle(cssText);\n    return createSimpleExpression(JSON.stringify(normalized), false, loc, 3 /* ConstantTypes.CAN_STRINGIFY */);\n};\n\nfunction createDOMCompilerError(code, loc) {\n    return createCompilerError(code, loc, (process.env.NODE_ENV !== 'production') || !true ? DOMErrorMessages : undefined);\n}\nconst DOMErrorMessages = {\n    [51 /* DOMErrorCodes.X_V_HTML_NO_EXPRESSION */]: `v-html is missing expression.`,\n    [52 /* DOMErrorCodes.X_V_HTML_WITH_CHILDREN */]: `v-html will override element children.`,\n    [53 /* DOMErrorCodes.X_V_TEXT_NO_EXPRESSION */]: `v-text is missing expression.`,\n    [54 /* DOMErrorCodes.X_V_TEXT_WITH_CHILDREN */]: `v-text will override element children.`,\n    [55 /* DOMErrorCodes.X_V_MODEL_ON_INVALID_ELEMENT */]: `v-model can only be used on <input>, <textarea> and <select> elements.`,\n    [56 /* DOMErrorCodes.X_V_MODEL_ARG_ON_ELEMENT */]: `v-model argument is not supported on plain elements.`,\n    [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.`,\n    [58 /* DOMErrorCodes.X_V_MODEL_UNNECESSARY_VALUE */]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,\n    [59 /* DOMErrorCodes.X_V_SHOW_NO_EXPRESSION */]: `v-show is missing expression.`,\n    [60 /* DOMErrorCodes.X_TRANSITION_INVALID_CHILDREN */]: `<Transition> expects exactly one child element or component.`,\n    [61 /* DOMErrorCodes.X_IGNORED_SIDE_EFFECT_TAG */]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`\n};\n\nconst transformVHtml = (dir, node, context) => {\n    const { exp, loc } = dir;\n    if (!exp) {\n        context.onError(createDOMCompilerError(51 /* DOMErrorCodes.X_V_HTML_NO_EXPRESSION */, loc));\n    }\n    if (node.children.length) {\n        context.onError(createDOMCompilerError(52 /* DOMErrorCodes.X_V_HTML_WITH_CHILDREN */, loc));\n        node.children.length = 0;\n    }\n    return {\n        props: [\n            createObjectProperty(createSimpleExpression(`innerHTML`, true, loc), exp || createSimpleExpression('', true))\n        ]\n    };\n};\n\nconst transformVText = (dir, node, context) => {\n    const { exp, loc } = dir;\n    if (!exp) {\n        context.onError(createDOMCompilerError(53 /* DOMErrorCodes.X_V_TEXT_NO_EXPRESSION */, loc));\n    }\n    if (node.children.length) {\n        context.onError(createDOMCompilerError(54 /* DOMErrorCodes.X_V_TEXT_WITH_CHILDREN */, loc));\n        node.children.length = 0;\n    }\n    return {\n        props: [\n            createObjectProperty(createSimpleExpression(`textContent`, true), exp\n                ? getConstantType(exp, context) > 0\n                    ? exp\n                    : createCallExpression(context.helperString(TO_DISPLAY_STRING), [exp], loc)\n                : createSimpleExpression('', true))\n        ]\n    };\n};\n\nconst transformModel = (dir, node, context) => {\n    const baseResult = transformModel$1(dir, node, context);\n    // base transform has errors OR component v-model (only need props)\n    if (!baseResult.props.length || node.tagType === 1 /* ElementTypes.COMPONENT */) {\n        return baseResult;\n    }\n    if (dir.arg) {\n        context.onError(createDOMCompilerError(56 /* DOMErrorCodes.X_V_MODEL_ARG_ON_ELEMENT */, dir.arg.loc));\n    }\n    function checkDuplicatedValue() {\n        const value = findProp(node, 'value');\n        if (value) {\n            context.onError(createDOMCompilerError(58 /* DOMErrorCodes.X_V_MODEL_UNNECESSARY_VALUE */, value.loc));\n        }\n    }\n    const { tag } = node;\n    const isCustomElement = context.isCustomElement(tag);\n    if (tag === 'input' ||\n        tag === 'textarea' ||\n        tag === 'select' ||\n        isCustomElement) {\n        let directiveToUse = V_MODEL_TEXT;\n        let isInvalidType = false;\n        if (tag === 'input' || isCustomElement) {\n            const type = findProp(node, `type`);\n            if (type) {\n                if (type.type === 7 /* NodeTypes.DIRECTIVE */) {\n                    // :type=\"foo\"\n                    directiveToUse = V_MODEL_DYNAMIC;\n                }\n                else if (type.value) {\n                    switch (type.value.content) {\n                        case 'radio':\n                            directiveToUse = V_MODEL_RADIO;\n                            break;\n                        case 'checkbox':\n                            directiveToUse = V_MODEL_CHECKBOX;\n                            break;\n                        case 'file':\n                            isInvalidType = true;\n                            context.onError(createDOMCompilerError(57 /* DOMErrorCodes.X_V_MODEL_ON_FILE_INPUT_ELEMENT */, dir.loc));\n                            break;\n                        default:\n                            // text type\n                            (process.env.NODE_ENV !== 'production') && checkDuplicatedValue();\n                            break;\n                    }\n                }\n            }\n            else if (hasDynamicKeyVBind(node)) {\n                // element has bindings with dynamic keys, which can possibly contain\n                // \"type\".\n                directiveToUse = V_MODEL_DYNAMIC;\n            }\n            else {\n                // text type\n                (process.env.NODE_ENV !== 'production') && checkDuplicatedValue();\n            }\n        }\n        else if (tag === 'select') {\n            directiveToUse = V_MODEL_SELECT;\n        }\n        else {\n            // textarea\n            (process.env.NODE_ENV !== 'production') && checkDuplicatedValue();\n        }\n        // inject runtime directive\n        // by returning the helper symbol via needRuntime\n        // the import will replaced a resolveDirective call.\n        if (!isInvalidType) {\n            baseResult.needRuntime = context.helper(directiveToUse);\n        }\n    }\n    else {\n        context.onError(createDOMCompilerError(55 /* DOMErrorCodes.X_V_MODEL_ON_INVALID_ELEMENT */, dir.loc));\n    }\n    // native vmodel doesn't need the `modelValue` props since they are also\n    // passed to the runtime as `binding.value`. removing it reduces code size.\n    baseResult.props = baseResult.props.filter(p => !(p.key.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ &&\n        p.key.content === 'modelValue'));\n    return baseResult;\n};\n\nconst isEventOptionModifier = /*#__PURE__*/ makeMap(`passive,once,capture`);\nconst isNonKeyModifier = /*#__PURE__*/ makeMap(\n// event propagation management\n`stop,prevent,self,` +\n    // system modifiers + exact\n    `ctrl,shift,alt,meta,exact,` +\n    // mouse\n    `middle`);\n// left & right could be mouse or key modifiers based on event type\nconst maybeKeyModifier = /*#__PURE__*/ makeMap('left,right');\nconst isKeyboardEvent = /*#__PURE__*/ makeMap(`onkeyup,onkeydown,onkeypress`, true);\nconst resolveModifiers = (key, modifiers, context, loc) => {\n    const keyModifiers = [];\n    const nonKeyModifiers = [];\n    const eventOptionModifiers = [];\n    for (let i = 0; i < modifiers.length; i++) {\n        const modifier = modifiers[i];\n        if (modifier === 'native' &&\n            checkCompatEnabled(\"COMPILER_V_ON_NATIVE\" /* CompilerDeprecationTypes.COMPILER_V_ON_NATIVE */, context, loc)) {\n            eventOptionModifiers.push(modifier);\n        }\n        else if (isEventOptionModifier(modifier)) {\n            // eventOptionModifiers: modifiers for addEventListener() options,\n            // e.g. .passive & .capture\n            eventOptionModifiers.push(modifier);\n        }\n        else {\n            // runtimeModifiers: modifiers that needs runtime guards\n            if (maybeKeyModifier(modifier)) {\n                if (isStaticExp(key)) {\n                    if (isKeyboardEvent(key.content)) {\n                        keyModifiers.push(modifier);\n                    }\n                    else {\n                        nonKeyModifiers.push(modifier);\n                    }\n                }\n                else {\n                    keyModifiers.push(modifier);\n                    nonKeyModifiers.push(modifier);\n                }\n            }\n            else {\n                if (isNonKeyModifier(modifier)) {\n                    nonKeyModifiers.push(modifier);\n                }\n                else {\n                    keyModifiers.push(modifier);\n                }\n            }\n        }\n    }\n    return {\n        keyModifiers,\n        nonKeyModifiers,\n        eventOptionModifiers\n    };\n};\nconst transformClick = (key, event) => {\n    const isStaticClick = isStaticExp(key) && key.content.toLowerCase() === 'onclick';\n    return isStaticClick\n        ? createSimpleExpression(event, true)\n        : key.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */\n            ? createCompoundExpression([\n                `(`,\n                key,\n                `) === \"onClick\" ? \"${event}\" : (`,\n                key,\n                `)`\n            ])\n            : key;\n};\nconst transformOn = (dir, node, context) => {\n    return transformOn$1(dir, node, context, baseResult => {\n        const { modifiers } = dir;\n        if (!modifiers.length)\n            return baseResult;\n        let { key, value: handlerExp } = baseResult.props[0];\n        const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);\n        // normalize click.right and click.middle since they don't actually fire\n        if (nonKeyModifiers.includes('right')) {\n            key = transformClick(key, `onContextmenu`);\n        }\n        if (nonKeyModifiers.includes('middle')) {\n            key = transformClick(key, `onMouseup`);\n        }\n        if (nonKeyModifiers.length) {\n            handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [\n                handlerExp,\n                JSON.stringify(nonKeyModifiers)\n            ]);\n        }\n        if (keyModifiers.length &&\n            // if event name is dynamic, always wrap with keys guard\n            (!isStaticExp(key) || isKeyboardEvent(key.content))) {\n            handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [\n                handlerExp,\n                JSON.stringify(keyModifiers)\n            ]);\n        }\n        if (eventOptionModifiers.length) {\n            const modifierPostfix = eventOptionModifiers.map(capitalize).join('');\n            key = isStaticExp(key)\n                ? createSimpleExpression(`${key.content}${modifierPostfix}`, true)\n                : createCompoundExpression([`(`, key, `) + \"${modifierPostfix}\"`]);\n        }\n        return {\n            props: [createObjectProperty(key, handlerExp)]\n        };\n    });\n};\n\nconst transformShow = (dir, node, context) => {\n    const { exp, loc } = dir;\n    if (!exp) {\n        context.onError(createDOMCompilerError(59 /* DOMErrorCodes.X_V_SHOW_NO_EXPRESSION */, loc));\n    }\n    return {\n        props: [],\n        needRuntime: context.helper(V_SHOW)\n    };\n};\n\nconst transformTransition = (node, context) => {\n    if (node.type === 1 /* NodeTypes.ELEMENT */ &&\n        node.tagType === 1 /* ElementTypes.COMPONENT */) {\n        const component = context.isBuiltInComponent(node.tag);\n        if (component === TRANSITION) {\n            return () => {\n                if (!node.children.length) {\n                    return;\n                }\n                // warn multiple transition children\n                if (hasMultipleChildren(node)) {\n                    context.onError(createDOMCompilerError(60 /* DOMErrorCodes.X_TRANSITION_INVALID_CHILDREN */, {\n                        start: node.children[0].loc.start,\n                        end: node.children[node.children.length - 1].loc.end,\n                        source: ''\n                    }));\n                }\n                // check if it's s single child w/ v-show\n                // if yes, inject \"persisted: true\" to the transition props\n                const child = node.children[0];\n                if (child.type === 1 /* NodeTypes.ELEMENT */) {\n                    for (const p of child.props) {\n                        if (p.type === 7 /* NodeTypes.DIRECTIVE */ && p.name === 'show') {\n                            node.props.push({\n                                type: 6 /* NodeTypes.ATTRIBUTE */,\n                                name: 'persisted',\n                                value: undefined,\n                                loc: node.loc\n                            });\n                        }\n                    }\n                }\n            };\n        }\n    }\n};\nfunction hasMultipleChildren(node) {\n    // #1352 filter out potential comment nodes.\n    const children = (node.children = node.children.filter(c => c.type !== 3 /* NodeTypes.COMMENT */ &&\n        !(c.type === 2 /* NodeTypes.TEXT */ && !c.content.trim())));\n    const child = children[0];\n    return (children.length !== 1 ||\n        child.type === 11 /* NodeTypes.FOR */ ||\n        (child.type === 9 /* NodeTypes.IF */ && child.branches.some(hasMultipleChildren)));\n}\n\nconst ignoreSideEffectTags = (node, context) => {\n    if (node.type === 1 /* NodeTypes.ELEMENT */ &&\n        node.tagType === 0 /* ElementTypes.ELEMENT */ &&\n        (node.tag === 'script' || node.tag === 'style')) {\n        context.onError(createDOMCompilerError(61 /* DOMErrorCodes.X_IGNORED_SIDE_EFFECT_TAG */, node.loc));\n        context.removeNode();\n    }\n};\n\nconst DOMNodeTransforms = [\n    transformStyle,\n    ...((process.env.NODE_ENV !== 'production') ? [transformTransition] : [])\n];\nconst DOMDirectiveTransforms = {\n    cloak: noopDirectiveTransform,\n    html: transformVHtml,\n    text: transformVText,\n    model: transformModel,\n    on: transformOn,\n    show: transformShow\n};\nfunction compile(template, options = {}) {\n    return baseCompile(template, extend({}, parserOptions, options, {\n        nodeTransforms: [\n            // ignore <script> and <tag>\n            // this is not put inside DOMNodeTransforms because that list is used\n            // by compiler-ssr to generate vnode fallback branches\n            ignoreSideEffectTags,\n            ...DOMNodeTransforms,\n            ...(options.nodeTransforms || [])\n        ],\n        directiveTransforms: extend({}, DOMDirectiveTransforms, options.directiveTransforms || {}),\n        transformHoist: null \n    }));\n}\nfunction parse(template, options = {}) {\n    return baseParse(template, extend({}, parserOptions, options));\n}\n\nexport { DOMDirectiveTransforms, DOMNodeTransforms, TRANSITION, TRANSITION_GROUP, V_MODEL_CHECKBOX, V_MODEL_DYNAMIC, V_MODEL_RADIO, V_MODEL_SELECT, V_MODEL_TEXT, V_ON_WITH_KEYS, V_ON_WITH_MODIFIERS, V_SHOW, compile, createDOMCompilerError, parse, parserOptions, transformStyle };\n","import * as runtimeDom from '@vue/runtime-dom';\nimport { initCustomFormatter, warn, registerRuntimeCompiler } from '@vue/runtime-dom';\nexport * from '@vue/runtime-dom';\nimport { compile } from '@vue/compiler-dom';\nimport { isString, NOOP, extend, generateCodeFrame } from '@vue/shared';\n\nfunction initDev() {\n    {\n        initCustomFormatter();\n    }\n}\n\n// This entry is the \"full-build\" that includes both the runtime\nif ((process.env.NODE_ENV !== 'production')) {\n    initDev();\n}\nconst compileCache = Object.create(null);\nfunction compileToFunction(template, options) {\n    if (!isString(template)) {\n        if (template.nodeType) {\n            template = template.innerHTML;\n        }\n        else {\n            (process.env.NODE_ENV !== 'production') && warn(`invalid template option: `, template);\n            return NOOP;\n        }\n    }\n    const key = template;\n    const cached = compileCache[key];\n    if (cached) {\n        return cached;\n    }\n    if (template[0] === '#') {\n        const el = document.querySelector(template);\n        if ((process.env.NODE_ENV !== 'production') && !el) {\n            warn(`Template element not found or is empty: ${template}`);\n        }\n        // __UNSAFE__\n        // Reason: potential execution of JS expressions in in-DOM template.\n        // The user must make sure the in-DOM template is trusted. If it's rendered\n        // by the server, the template should not contain any user data.\n        template = el ? el.innerHTML : ``;\n    }\n    const opts = extend({\n        hoistStatic: true,\n        onError: (process.env.NODE_ENV !== 'production') ? onError : undefined,\n        onWarn: (process.env.NODE_ENV !== 'production') ? e => onError(e, true) : NOOP\n    }, options);\n    if (!opts.isCustomElement && typeof customElements !== 'undefined') {\n        opts.isCustomElement = tag => !!customElements.get(tag);\n    }\n    const { code } = compile(template, opts);\n    function onError(err, asWarning = false) {\n        const message = asWarning\n            ? err.message\n            : `Template compilation error: ${err.message}`;\n        const codeFrame = err.loc &&\n            generateCodeFrame(template, err.loc.start.offset, err.loc.end.offset);\n        warn(codeFrame ? `${message}\\n${codeFrame}` : message);\n    }\n    // The wildcard import results in a huge object with every export\n    // with keys that cannot be mangled, and can be quite heavy size-wise.\n    // In the global build we know `Vue` is available globally so we can avoid\n    // the wildcard object.\n    const render = (new Function('Vue', code)(runtimeDom));\n    render._rc = true;\n    return (compileCache[key] = render);\n}\nregisterRuntimeCompiler(compileToFunction);\n\nexport { compileToFunction as compile };\n","import { nextTick, openBlock, createBlock, createVNode, withKeys, withModifiers, renderSlot, createCommentVNode, withDirectives, Fragment, renderList, toDisplayString, vShow } from 'vue';\n\nconst CONFIG = {\n  HOUR_TOKENS: ['HH', 'H', 'hh', 'h', 'kk', 'k'],\n  MINUTE_TOKENS: ['mm', 'm'],\n  SECOND_TOKENS: ['ss', 's'],\n  APM_TOKENS: ['A', 'a'],\n  BASIC_TYPES: ['hour', 'minute', 'second', 'apm']\n};\n\nconst DEFAULT_OPTIONS = {\n  format: 'HH:mm',\n  minuteInterval: 1,\n  secondInterval: 1,\n  hourRange: null,\n  minuteRange: null,\n  secondRange: null,\n  hideDisabledHours: false,\n  hideDisabledMinutes: false,\n  hideDisabledSeconds: false,\n  hideDisabledItems: false,\n  advancedKeyboard: false,\n  hideDropdown: false,\n  blurDelay: 300,\n  manualInputTimeout: 1000,\n  dropOffsetHeight: 160\n};\n\nvar script = {\n  name: 'VueTimepicker',\n\n  props: {\n    modelValue: { type: [ Object, String ] },\n    format: { type: String },\n    minuteInterval: { type: [ Number, String ] },\n    secondInterval: { type: [ Number, String ] },\n\n    hourRange: { type: Array },\n    minuteRange: { type: Array },\n    secondRange: { type: Array },\n\n    hideDisabledHours: { type: Boolean, default: false },\n    hideDisabledMinutes: { type: Boolean, default: false },\n    hideDisabledSeconds: { type: Boolean, default: false },\n    hideDisabledItems: { type: Boolean, default: false },\n\n    hideClearButton: { type: Boolean, default: false },\n    disabled: { type: Boolean, default: false },\n    closeOnComplete: { type: Boolean, default: false },\n\n    id: { type: String },\n    name: { type: String },\n    inputClass: { type: [ String, Object, Array ] },\n    placeholder: { type: String },\n    tabindex: { type: [ Number, String ], default: 0 },\n    inputWidth: { type: String },\n    autocomplete: { type: String, default: 'off' },\n\n    hourLabel: { type: String },\n    minuteLabel: { type: String },\n    secondLabel: { type: String },\n    apmLabel: { type: String },\n    amText: { type: String },\n    pmText: { type: String },\n\n    blurDelay: { type: [ Number, String ] },\n    advancedKeyboard: { type: Boolean, default: false },\n\n    lazy: { type: Boolean, default: false },\n    autoScroll: { type: Boolean, default: false },\n\n    dropDirection: { type: String, default: 'down' },\n    dropOffsetHeight: { type: [ Number, String ] },\n    containerId: { type: String },\n\n    manualInput: { type: Boolean, default: false },\n    manualInputTimeout: { type: [ Number, String ] },\n    hideDropdown: { type: Boolean, default: false },\n    fixedDropdownButton: { type: Boolean, default: false },\n\n    debugMode: { type: Boolean, default: false }\n  },\n\n  data () {\n    return {\n      timeValue: {},\n\n      hours: [],\n      minutes: [],\n      seconds: [],\n      apms: [],\n\n      isActive: false,\n      showDropdown: false,\n      isFocusing: false,\n      debounceTimer: undefined,\n\n      hourType: 'HH',\n      minuteType: 'mm',\n      secondType: '',\n      apmType: '',\n      hour: '',\n      minute: '',\n      second: '',\n      apm: '',\n      fullValues: undefined,\n      bakDisplayTime: undefined,\n      doClearApmChecking: false,\n\n      selectionTimer: undefined,\n      kbInputTimer: undefined,\n      kbInputLog: '',\n      bakCurrentPos: undefined,\n      forceDropOnTop: false\n    }\n  },\n\n  emits: ['update:modelValue', 'change', 'open', 'close', 'focus', 'blur', 'error'],\n\n  computed: {\n    opts () {\n      const options = Object.assign({}, DEFAULT_OPTIONS);\n\n      if (this.format && this.format.length) {\n        options.format = String(this.format);\n      }\n\n      if (this.isNumber(this.minuteInterval)) {\n        options.minuteInterval = +this.minuteInterval;\n      }\n      // minuteInterval failsafe\n      if (!options.minuteInterval || options.minuteInterval < 1 || options.minuteInterval > 60) {\n        if (this.debugMode) {\n          if (options.minuteInterval > 60) {\n            this.debugLog(`\"minute-interval\" should be less than 60. Current value is ${this.minuteInterval}`);\n          } else if (options.minuteInterval === 0 || options.minuteInterval < 1) {\n            this.debugLog(`\"minute-interval\" should be NO less than 1. Current value is ${this.minuteInterval}`);\n          }\n        }\n        if (options.minuteInterval === 0) {\n          options.minuteInterval = 60;\n        } else {\n          options.minuteInterval = 1;\n        }\n      }\n\n      if (this.isNumber(this.secondInterval)) {\n        options.secondInterval = +this.secondInterval;\n      }\n      // secondInterval failsafe\n      if (!options.secondInterval || options.secondInterval < 1 || options.secondInterval > 60) {\n        if (this.debugMode) {\n          if (options.secondInterval > 60) {\n            this.debugLog(`\"second-interval\" should be less than 60. Current value is ${this.secondInterval}`);\n          } else if (options.secondInterval === 0 || options.secondInterval < 1) {\n            this.debugLog(`\"second-interval\" should be NO less than 1. Current value is ${this.secondInterval}`);\n          }\n        }\n        if (options.secondInterval === 0) {\n          options.secondInterval = 60;\n        } else {\n          options.secondInterval = 1;\n        }\n      }\n\n      if (this.hourRange && Array.isArray(this.hourRange)) {\n        options.hourRange = JSON.parse(JSON.stringify(this.hourRange));\n        if (!this.hourRange.length && this.debugMode) {\n          this.debugLog('The \"hour-range\" array is empty (length === 0)');\n        }\n      }\n\n      if (this.minuteRange && Array.isArray(this.minuteRange)) {\n        options.minuteRange = JSON.parse(JSON.stringify(this.minuteRange));\n        if (!this.minuteRange.length && this.debugMode) {\n          this.debugLog('The \"minute-range\" array is empty (length === 0)');\n        }\n      }\n\n      if (this.secondRange && Array.isArray(this.secondRange)) {\n        options.secondRange = JSON.parse(JSON.stringify(this.secondRange));\n        if (!this.secondRange.length && this.debugMode) {\n          this.debugLog('The \"second-range\" array is empty (length === 0)');\n        }\n      }\n\n      if (this.hideDisabledItems) {\n        options.hideDisabledItems = true;\n      }\n\n      if (this.hideDisabledHours || this.hideDisabledItems) {\n        options.hideDisabledHours = true;\n      }\n      if (this.hideDisabledMinutes || this.hideDisabledItems) {\n        options.hideDisabledMinutes = true;\n      }\n      if (this.hideDisabledSeconds || this.hideDisabledItems) {\n        options.hideDisabledSeconds = true;\n      }\n\n      if (this.hideDropdown) {\n        if (this.manualInput) {\n          options.hideDropdown = true;\n        } else if (this.debugMode) {\n          this.debugLog('\"hide-dropdown\" only works with \"manual-input\" mode');\n        }\n      }\n\n      if (this.blurDelay && +this.blurDelay > 0) {\n        options.blurDelay = +this.blurDelay;\n      }\n\n      if (this.manualInputTimeout && +this.manualInputTimeout > 0) {\n        options.manualInputTimeout = +this.manualInputTimeout;\n      }\n\n      if (this.dropOffsetHeight && +this.dropOffsetHeight > 0) {\n        options.dropOffsetHeight = +this.dropOffsetHeight;\n      }\n\n      return options\n    },\n\n    useStringValue () {\n      return typeof this.modelValue === 'string'\n    },\n\n    formatString () {\n      return this.opts.format || DEFAULT_OPTIONS.format\n    },\n\n    inUse () {\n      const typesInUse = CONFIG.BASIC_TYPES.filter(type => this.getTokenByType(type));\n      // Sort types and tokens by their sequence in the \"format\" string\n      typesInUse.sort((l, r) => {\n        return this.formatString.indexOf(this.getTokenByType(l) || null) - this.formatString.indexOf(this.getTokenByType(r) || null)\n      });\n      const tokensInUse = typesInUse.map(type => this.getTokenByType(type));\n      return {\n        hour: !!this.hourType,\n        minute: !!this.minuteType,\n        second: !!this.secondType,\n        apm: !!this.apmType,\n        types: typesInUse || [],\n        tokens: tokensInUse || []\n      }\n    },\n\n    displayTime () {\n      let formatString = String(this.formatString);\n      if (this.hour) {\n        formatString = formatString.replace(new RegExp(this.hourType, 'g'), this.hour);\n      }\n      if (this.minute) {\n        formatString = formatString.replace(new RegExp(this.minuteType, 'g'), this.minute);\n      }\n      if (this.second && this.secondType) {\n        formatString = formatString.replace(new RegExp(this.secondType, 'g'), this.second);\n      }\n      if (this.apm && this.apmType) {\n        formatString = formatString.replace(new RegExp(this.apmType, 'g'), this.apm);\n      }\n      return formatString\n    },\n\n    customDisplayTime () {\n      if (!this.amText && !this.pmText) {\n        return this.displayTime\n      }\n      return this.displayTime.replace(new RegExp(this.apm, 'g'), this.apmDisplayText(this.apm))\n    },\n\n    inputIsEmpty () {\n      return this.formatString === this.displayTime\n    },\n\n    allValueSelected () {\n      if (\n        (this.inUse.hour && !this.hour) ||\n        (this.inUse.minute && !this.minute) ||\n        (this.inUse.second && !this.second) ||\n        (this.inUse.apm && !this.apm)\n      ) {\n        return false\n      }\n      return true\n    },\n\n    columnsSequence () {\n      return this.inUse.types.map(type => type) || []\n    },\n\n    showClearBtn () {\n      if (this.hideClearButton || this.disabled) {\n        return false\n      }\n      return !this.inputIsEmpty\n    },\n\n    showDropdownBtn () {\n      if (this.fixedDropdownButton) { return true }\n      if (this.opts.hideDropdown && this.isActive && !this.showDropdown) {\n        return true\n      }\n      return false\n    },\n\n    baseOn12Hours () {\n      return this.hourType === 'h' || this.hourType === 'hh'\n    },\n\n    hourRangeIn24HrFormat () {\n      if (!this.hourType || !this.opts.hourRange) { return false }\n      if (!this.opts.hourRange.length) { return [] }\n\n      const range = [];\n      this.opts.hourRange.forEach(value => {\n        if (value instanceof Array) {\n          if (value.length > 2 && this.debugMode) {\n            this.debugLog(`Nested array within \"hour-range\" must contain no more than two items. Only the first two items of ${JSON.stringify(value)} will be taken into account.`);\n          }\n\n          let start = value[0];\n          let end = value[1] || value[0];\n\n          if (this.is12hRange(start)) {\n            start = this.translate12hRange(start);\n          }\n          if (this.is12hRange(end)) {\n            end = this.translate12hRange(end);\n          }\n\n          for (let i = +start; i <= +end; i++) {\n            if (i < 0 || i > 24) { continue }\n            if (!range.includes(i)) {\n              range.push(i);\n            }\n          }\n        } else {\n          if (this.is12hRange(value)) {\n            value = this.translate12hRange(value);\n          } else {\n            value = +value;\n          }\n          if (value < 0 || value > 24) { return }\n          if (!range.includes(value)) {\n            range.push(value);\n          }\n        }\n      });\n      range.sort((l, r) => { return l - r });\n      return range\n    },\n\n    restrictedHourRange () {\n      // No restriction\n      if (!this.hourRangeIn24HrFormat) { return false }\n      // 12-Hour\n      if (this.baseOn12Hours) {\n        const range = this.hourRangeIn24HrFormat.map((value) => {\n          if (value === 12) {\n            return '12p'\n          } else if (value === 24 || value === 0) {\n            return '12a'\n          }\n          return value > 12 ? `${value % 12}p` : `${value}a`\n        });\n        return range\n      }\n      // 24-Hour\n      return this.hourRangeIn24HrFormat\n    },\n\n    validHoursList () {\n      if (!this.manualInput) { return false }\n      if (this.restrictedHourRange) {\n        let list = [];\n        if (this.baseOn12Hours) {\n          list = this.restrictedHourRange.map(hr => {\n            const l = hr.substr(0, hr.length - 1);\n            const r = hr.substr(-1);\n            return `${this.formatValue(this.hourType, l)}${r}`\n          });\n          const am12Index = list.indexOf('12a');\n          if (am12Index > 0) {\n            // Make '12a' the first item in h/hh\n            list.unshift(list.splice(am12Index, 1)[0]);\n          }\n          return list\n        }\n        list = this.restrictedHourRange.map(hr => {\n          return this.formatValue(this.hourType, hr)\n        });\n        if (list.length > 1 && list[0] && list[0] === '24') {\n          // Make '24' the last item in k/kk\n          list.push(list.shift());\n        }\n        return list\n      }\n      if (this.baseOn12Hours) {\n        return [].concat([], this.hours.map(hr => `${hr}a`), this.hours.map(hr => `${hr}p`))\n      }\n      return this.hours\n    },\n\n    has () {\n      const result = {\n        customApmText: false\n      };\n      const apmEnabled = !!this.apmType;\n\n      if (apmEnabled && this.hourRangeIn24HrFormat && this.hourRangeIn24HrFormat.length) {\n        const range = [].concat([], this.hourRangeIn24HrFormat);\n        result.am = range.some(value => value < 12 || value === 24);\n        result.pm = range.some(value => value >= 12 && value < 24);\n      } else {\n        result.am = apmEnabled;\n        result.pm = apmEnabled;\n      }\n      if ((this.amText && this.amText.length) || (this.pmText && this.pmText.length)) {\n        result.customApmText = true;\n      }\n      return result\n    },\n\n    minuteRangeList () {\n      if (!this.minuteType || !this.opts.minuteRange) { return false }\n      if (!this.opts.minuteRange.length) { return [] }\n      return this.renderRangeList(this.opts.minuteRange, 'minute')\n    },\n\n    secondRangeList () {\n      if (!this.secondType || !this.opts.secondRange) { return false }\n      if (!this.opts.secondRange.length) { return [] }\n      return this.renderRangeList(this.opts.secondRange, 'second')\n    },\n    \n    hourLabelText () {\n      return this.hourLabel || this.hourType\n    },\n    minuteLabelText () {\n      return this.minuteLabel || this.minuteType\n    },\n    secondLabelText() {\n      return this.secondLabel || this.secondType\n    },\n    apmLabelText () {\n      return this.apmLabel || this.apmType\n    },\n\n    inputWidthStyle () {\n      if (!this.inputWidth || !this.inputWidth.length) { return }\n      return {\n        width: this.inputWidth\n      }\n    },\n\n    tokenRegexBase () {\n      return this.inUse.tokens.join('|')\n    },\n\n    tokenChunks () {\n      if (!this.manualInput && !this.useStringValue) { return false }\n\n      const formatString = String(this.formatString);\n      const tokensRegxStr = `(${this.tokenRegexBase})+?`;\n      const tokensMatchAll = this.getMatchAllByRegex(formatString, tokensRegxStr);\n\n      const tokenChunks = [];\n      for (let tkMatch of tokensMatchAll) {\n        const rawToken = tkMatch[0];\n        const tokenMatchItem = {\n          index: tkMatch.index,\n          token: rawToken,\n          type: this.getTokenType(rawToken),\n          needsCalibrate: rawToken.length < 2,\n          len: (rawToken || '').length\n        };\n        tokenChunks.push(tokenMatchItem);\n      }\n      return tokenChunks\n    },\n\n    needsPosCalibrate () {\n      if (!this.manualInput) { return false }\n      return this.tokenChunks.some(chk => chk.needsCalibrate)\n    },\n\n    tokenChunksPos () {\n      if (!this.manualInput) { return false }\n      if (!this.needsPosCalibrate) {\n        return this.tokenChunks.map(chk => {\n          return {\n            token: chk.token,\n            type: chk.type,\n            start: chk.index,\n            end: chk.index + chk.len\n          }\n        })\n      }\n      const list = [];\n      let calibrateLen = 0;\n      this.tokenChunks.forEach(chk => {\n        let chunkCurrentLen;\n        // Adjust for customized AM/PM text\n        if (chk.type === 'apm' && this.has.customApmText) {\n          if (this.apm && this.apm.length) {\n            const customApmText = this.apm.toLowerCase() === 'am' ? this.amText : this.pmText;\n            chunkCurrentLen = (customApmText && customApmText.length) ? customApmText.length : chk.len;\n          } else {\n            chunkCurrentLen = chk.len;\n          }\n        // Others\n        } else {\n          chunkCurrentLen = this[chk.type] && this[chk.type].length ? this[chk.type].length : chk.len;\n        }\n        list.push({\n          token: chk.token,\n          type: chk.type,\n          start: chk.index + calibrateLen,\n          end: chk.index + calibrateLen + chunkCurrentLen\n        });\n        if (chk.needsCalibrate && chunkCurrentLen > chk.len) {\n          calibrateLen += (chunkCurrentLen - chk.len);\n        }\n      });\n      return list\n    },\n\n    invalidValues () {\n      if (this.inputIsEmpty) { return [] }\n      if (!this.restrictedHourRange && !this.minuteRangeList && !this.secondRangeList && this.opts.minuteInterval === 1 && this.opts.secondInterval === 1) { return [] }\n\n      const result = [];\n      if (this.inUse.hour && !this.isEmptyValue(this.hourType, this.hour) && (!this.isValidValue(this.hourType, this.hour) || this.isDisabled('hour', this.hour))) {\n        result.push('hour');\n      }\n      if (this.inUse.minute && !this.isEmptyValue(this.minuteType, this.minute) && (!this.isValidValue(this.minuteType, this.minute) || this.isDisabled('minute', this.minute) || this.notInInterval('minute', this.minute))) {\n        result.push('minute');\n      }\n      if (this.inUse.second && !this.isEmptyValue(this.secondType, this.second) && (!this.isValidValue(this.secondType, this.second) || this.isDisabled('second', this.second) || this.notInInterval('second', this.second))) {\n        result.push('second');\n      }\n      if (this.inUse.apm && !this.isEmptyValue(this.apmType, this.apm) && (!this.isValidValue(this.apmType, this.apm) || this.isDisabled('apm', this.apm))) {\n        result.push('apm');\n      }\n      if (result.length) {\n        return result\n      }\n      return []\n    },\n\n    hasInvalidInput () {\n      return Boolean(this.invalidValues && this.invalidValues.length)\n    },\n\n    autoDirectionEnabled () {\n      return this.dropDirection === 'auto'\n    },\n\n    dropdownDirClass () {\n      if (this.autoDirectionEnabled) {\n        return this.forceDropOnTop ? 'drop-up' : 'drop-down'\n      }\n      return this.dropDirection === 'up' ? 'drop-up' : 'drop-down'      \n    }\n  },\n\n  watch: {\n    'opts.format' (newValue) {\n      this.renderFormat(newValue);\n    },\n    'opts.minuteInterval' (newInteval) {\n      this.renderList('minute', newInteval);\n    },\n    'opts.secondInterval' (newInteval) {\n      this.renderList('second', newInteval);\n    },\n    value: {\n      deep: true,\n      handler () {\n        this.readValues();\n      }\n    },\n    displayTime () {\n      this.fillValues();\n    },\n    disabled (toDisabled) {\n      if (toDisabled) {\n        // Force close dropdown and reset status when disabled\n        if (this.isActive) {\n          this.isActive = false;\n        }\n        if (this.showDropdown) {\n          this.showDropdown = false;\n        }\n      }\n    },\n    'invalidValues.length' (newLength, oldLength) {\n      if (newLength && newLength >= 1) {\n        this.$emit('error', this.invalidValues);\n      } else if (oldLength && oldLength >= 1) {\n        this.$emit('error', []);\n      }\n    }\n  },\n\n  methods: {\n    formatValue (token, i) {\n      if (!this.isNumber(i)) { return '' }\n      i = +i;\n      switch (token) {\n        case 'H':\n        case 'h':\n        case 'k':\n        case 'm':\n        case 's':\n          if (['h', 'k'].includes(token) && i === 0) {\n            return token === 'k' ? '24' : '12'\n          }\n          return String(i)\n        case 'HH':\n        case 'mm':\n        case 'ss':\n        case 'hh':\n        case 'kk':\n          if (['hh', 'kk'].includes(token) && i === 0) {\n            return token === 'kk' ? '24' : '12'\n          }\n          return i < 10 ? `0${i}` : String(i)\n        default:\n          return ''\n      }\n    },\n\n    checkAcceptingType (validValues, formatString) {\n      if (!validValues || !formatString || !formatString.length) { return '' }\n      for (let i = 0; i < validValues.length; i++) {\n        if (formatString.indexOf(validValues[i]) > -1) {\n          return validValues[i]\n        }\n      }\n      return ''\n    },\n\n    renderFormat (newFormat) {\n      newFormat = newFormat || this.opts.format || DEFAULT_OPTIONS.format;\n\n      let hourType = this.checkAcceptingType(CONFIG.HOUR_TOKENS, newFormat);\n      let minuteType = this.checkAcceptingType(CONFIG.MINUTE_TOKENS, newFormat);\n      this.secondType = this.checkAcceptingType(CONFIG.SECOND_TOKENS, newFormat);\n      this.apmType = this.checkAcceptingType(CONFIG.APM_TOKENS, newFormat);\n\n      // Failsafe checking\n      if (!hourType && !minuteType && !this.secondType && !this.apmType) {\n        if (this.debugMode && this.format) {\n          this.debugLog(`No valid tokens found in your defined \"format\" string \"${this.format}\". Fallback to the default \"HH:mm\" format.`);\n        }\n        hourType = 'HH';\n        minuteType = 'mm';\n      }\n      this.hourType = hourType;\n      this.minuteType = minuteType;\n\n      this.hourType ? this.renderHoursList() : this.hours = [];\n      this.minuteType ? this.renderList('minute') : this.minutes = [];\n      this.secondType ? this.renderList('second') : this.seconds = [];\n      this.apmType ? this.renderApmList() : this.apms = [];\n\n      nextTick(() => {\n        this.readValues();\n      });\n    },\n\n    renderHoursList () {\n      const hoursCount = this.baseOn12Hours ? 12 : 24;\n      const hours = [];\n      for (let i = 0; i < hoursCount; i++) {\n        if (this.hourType === 'k' || this.hourType === 'kk') {\n          hours.push(this.formatValue(this.hourType, i + 1));\n        } else {\n          hours.push(this.formatValue(this.hourType, i));\n        }\n      }\n      this.hours = hours;\n    },\n\n    renderList (listType, interval) {\n      if (!this.isMinuteOrSecond(listType)) { return }\n\n      const isMinute = listType === 'minute';\n      interval = interval || (isMinute ? (this.opts.minuteInterval || DEFAULT_OPTIONS.minuteInterval) : (this.opts.secondInterval || DEFAULT_OPTIONS.secondInterval));\n\n      const result = [];\n      for (let i = 0; i < 60; i += interval) {\n        result.push(this.formatValue(isMinute ? this.minuteType : this.secondType, i));\n      }\n      isMinute ? this.minutes = result : this.seconds = result;\n    },\n\n    renderApmList () {\n      this.apms = this.apmType === 'A' ? ['AM', 'PM'] : ['am', 'pm'];\n    },\n\n    readValues () {\n      if (this.useStringValue) {\n        if (this.debugMode) {\n          this.debugLog(`Received a string value: \"${this.modelValue}\"`);\n        }\n        this.readStringValues(this.modelValue);\n      } else {\n        if (this.debugMode) {\n          this.debugLog(`Received an object value: \"${JSON.stringify(this.modelValue || {})}\"`);\n        }\n        this.readObjectValues(this.modelValue);\n      }\n    },\n\n    readObjectValues (objValue) {\n      const timeValue = JSON.parse(JSON.stringify(objValue || {}));\n      const values = Object.keys(timeValue);\n\n      // Failsafe for empty `v-model` object\n      if (values.length === 0) {\n        this.addFallbackValues();\n        return\n      }\n\n      CONFIG.BASIC_TYPES.forEach(type => {\n        const token = this.getTokenByType(type);\n        if (values.indexOf(token) > -1) {\n          const sanitizedValue = this.sanitizedValue(token, timeValue[token]);\n          this[type] = sanitizedValue;\n          timeValue[token] = sanitizedValue;\n        } else {\n          this[type] = '';\n        }\n      });\n      this.timeValue = timeValue;\n    },\n\n    getMatchAllByRegex (testString, regexString) {\n      const str = 'polyfillTest';\n      const needsPolyfill = Boolean(!str.matchAll || typeof str.matchAll !== 'function');\n      return needsPolyfill ? this.polyfillMatchAll(testString, regexString) : testString.matchAll(new RegExp(regexString, 'g'))\n    },\n\n    readStringValues (stringValue) {\n      // Failsafe for empty `v-model` string\n      if (!stringValue || !stringValue.length) {\n        this.addFallbackValues();\n        return\n      }\n\n      const formatString = String(this.formatString);\n      const tokensRegxStr = `(${this.tokenRegexBase})+?`;\n      const othersRegxStr = `[^(${this.tokenRegexBase})]+`;\n\n      const tokensMatchAll = this.getMatchAllByRegex(formatString, tokensRegxStr);\n      const othersMatchAll = this.getMatchAllByRegex(formatString, othersRegxStr);\n\n      const chunks = [];\n      const tokenChunks = [];\n\n      for (let tkMatch of tokensMatchAll) {\n        const tokenMatchItem = {\n          index: tkMatch.index,\n          token: tkMatch[0],\n          isValueToken: true\n        };\n        chunks.push(tokenMatchItem);\n        tokenChunks.push(tokenMatchItem);\n      }\n\n      for (let otMatch of othersMatchAll) {\n        chunks.push({\n          index: otMatch.index,\n          token: otMatch[0]\n        });\n      }\n\n      chunks.sort((l, r) => l.index < r.index ? -1 : 1);\n\n      let regexCombo = '';\n      chunks.forEach(chunk => {\n        if (chunk.isValueToken) {\n          const tokenRegex = this.getTokenRegex(chunk.token) || '';\n          regexCombo += tokenRegex;\n        } else {\n          const safeChars = chunk.token.replace(/\\\\{0}(\\*|\\?|\\.|\\+)/g, '\\\\$1');\n          regexCombo += `(?:${safeChars})`;\n        }\n      });\n\n      const comboReg = new RegExp(regexCombo);\n\n      // Do test before match\n      if (comboReg.test(stringValue)) {\n        const matchResults = stringValue.match(new RegExp(regexCombo));\n        const valueResults = matchResults.slice(1, tokenChunks.length + 1);\n        const timeValue = {};\n        valueResults.forEach((value, vrIndex) => {\n          if (tokenChunks[vrIndex]) {\n            const targetToken = tokenChunks[vrIndex].token;\n            timeValue[targetToken] = this.setValueFromString(value, targetToken);\n          }\n        });\n        this.timeValue = timeValue;\n\n        if (this.debugMode) {\n          const tokenChunksForLog = tokenChunks.map(tChunk => tChunk && tChunk.token);\n          this.debugLog(`Successfully parsed values ${JSON.stringify(valueResults)}\\nfor ${JSON.stringify(tokenChunksForLog)}\\nin format pattern '${this.formatString}'`);\n        }\n      } else {\n        if (this.debugMode) {\n          this.debugLog(`The input string in \"v-model\" does NOT match the \"format\" pattern\\nformat: ${this.formatString}\\nv-model: ${stringValue}`);\n        }\n      }\n    },\n\n    polyfillMatchAll (targetString, regxStr) {\n      const matchesList = targetString.match(new RegExp(regxStr, 'g'));\n      const result = [];\n      const indicesReg = [];\n      if (matchesList && matchesList.length) {\n        matchesList.forEach(matchedItem => {\n          const existIndex = indicesReg.findIndex(idxItem => idxItem.str === matchedItem);\n          let index;\n          if (existIndex >= 0) {\n            if (indicesReg[existIndex] && indicesReg[existIndex].regex) {\n              index = indicesReg[existIndex].regex.exec(targetString).index;\n            }\n          } else {\n            const itemIndicesRegex = new RegExp(matchedItem, 'g');\n            index = itemIndicesRegex.exec(targetString).index;\n            indicesReg.push({\n              str: String(matchedItem),\n              regex: itemIndicesRegex\n            });\n          }\n          result.push({\n            0: String(matchedItem),\n            index: index\n          });\n        });\n      }\n      return result\n    },\n\n    addFallbackValues () {\n      const timeValue = {};\n      this.inUse.types.forEach(type => {\n        timeValue[this.getTokenByType(type)] = '';\n      });\n      this.timeValue = timeValue;\n    },\n\n    setValueFromString (parsedValue, token) {\n      if (!token || !parsedValue) { return '' }\n      const tokenType = this.getTokenType(token);\n      if (!tokenType || !tokenType.length) { return '' }\n      const stdValue = (parsedValue !== this.getTokenByType(tokenType)) ? parsedValue : '';\n      this[tokenType] = stdValue;\n      return stdValue\n    },\n\n    fillValues (forceEmit) {\n      const fullValues = {};\n\n      const baseHour = this.hour;\n      const baseHourType = this.hourType;\n\n      let apmValue;\n\n      // Hour type or hour value is NOT set in the \"format\" string\n      if (!baseHourType || !this.isNumber(baseHour)) {\n        CONFIG.HOUR_TOKENS.forEach(token => fullValues[token] = '');\n        apmValue = this.lowerCasedApm(this.apm || '');\n        fullValues.a = apmValue;\n        fullValues.A = apmValue.toUpperCase();\n\n      // Both Hour type and value are set\n      } else {\n        const hourValue = +baseHour;\n        const apmValue = (this.baseOn12Hours && this.apm) ? this.lowerCasedApm(this.apm) : false;\n\n        CONFIG.HOUR_TOKENS.forEach((token) => {\n          if (token === baseHourType) {\n            fullValues[token] = baseHour;\n            return\n          }\n\n          let value;\n          let apm;\n          switch (token) {\n            case 'H':\n            case 'HH':\n            case 'k':\n            case 'kk':\n              if (this.baseOn12Hours) {\n                if (apmValue === 'pm') {\n                  value = hourValue < 12 ? hourValue + 12 : hourValue;\n                } else if (['k', 'kk'].includes(token)) {\n                  value = hourValue === 12 ? 24 : hourValue;\n                } else {\n                  value = hourValue % 12;\n                }\n              } else {\n                if (['k', 'kk'].includes(token)) {\n                  value = hourValue === 0 ? 24 : hourValue;\n                } else {\n                  value = hourValue % 24;\n                }\n              }\n              fullValues[token] = this.formatValue(token, value);\n              break\n            case 'h':\n            case 'hh':\n              // h <-> hh\n              if (this.baseOn12Hours) {\n                value = hourValue;\n                apm = apmValue || '';\n              // Read from other hour formats\n              } else {\n                if (hourValue > 11 && hourValue < 24) {\n                  apm = 'pm';\n                  value = hourValue === 12 ? 12 : hourValue % 12;\n                } else {\n                  apm = 'am';\n                  value = hourValue % 12 === 0 ? 12 : hourValue;\n                }\n              }\n              fullValues[token] = this.formatValue(token, value);\n              fullValues.a = apm;\n              fullValues.A = apm.toUpperCase();\n              break\n          }\n        });\n      }\n\n      fullValues.m = this.formatValue('m', this.minute);\n      fullValues.mm = this.formatValue('mm', this.minute);\n      fullValues.s = this.formatValue('s', this.second);\n      fullValues.ss = this.formatValue('ss', this.second);\n\n      this.fullValues = fullValues;\n\n      // On lazy mode, emit `input` and `change` events only when:\n      // - The user pick a new value and then close the dropdown\n      // - The user click the (\"x\") clear button\n      if (!this.lazy || forceEmit) {\n        this.emitTimeValue();\n      }\n\n      if (this.closeOnComplete && this.allValueSelected && this.showDropdown) {\n        this.toggleActive();\n      }\n    },\n\n    emitTimeValue () {\n      if (!this.fullValues) { return }\n\n      if (this.lazy && this.bakDisplayTime === this.displayTime) {\n        if (this.debugMode) {\n          this.debugLog('The value does not change on `lazy` mode. Skip the emitting `input` and `change` event.');\n        }\n        return\n      }\n\n      const fullValues = JSON.parse(JSON.stringify(this.fullValues));\n\n      if (this.useStringValue) {\n        this.$emit('update:modelValue', this.inputIsEmpty ? '' : String(this.displayTime));\n      } else {\n        const tokensInUse = this.inUse.tokens || [];\n        const timeValue = {};\n        tokensInUse.forEach((token) => {\n          timeValue[token] = fullValues[token] || '';\n        });\n        this.$emit('update:modelValue', JSON.parse(JSON.stringify(timeValue)));\n      }\n\n      this.$emit('change', {\n        data: fullValues,\n        displayTime: this.inputIsEmpty ? '' : String(this.displayTime)\n      });\n    },\n\n    translate12hRange (value) {\n      const valueT = this.match12hRange(value);\n      if (+valueT[1] === 12) {\n        return +valueT[1] + (valueT[2].toLowerCase() === 'p' ? 0 : 12)\n      }\n      return +valueT[1] + (valueT[2].toLowerCase() === 'p' ? 12 : 0)\n    },\n\n    isDisabled (type, value) {\n      if (!this.isBasicType(type) || !this.inUse[type]) { return true }\n      switch (type) {\n        case 'hour':\n          return this.isDisabledHour(value)\n        case 'minute':\n        case 'second':\n          if (!this[`${type}RangeList`]) {\n            return false\n          }\n          return !this[`${type}RangeList`].includes(value)\n        case 'apm':\n          if (!this.restrictedHourRange) {\n            return false\n          }\n          return !this.has[this.lowerCasedApm(value)]\n        default:\n          return true\n      }\n    },\n\n    isDisabledHour (value) {\n      if (!this.restrictedHourRange) { return false }\n      if (this.baseOn12Hours) {\n        if (!this.apm || !this.apm.length) {\n          return false\n        } else {\n          const token = this.apm.toLowerCase() === 'am' ? 'a' : 'p';\n          return !this.restrictedHourRange.includes(`${+value}${token}`)\n        }\n      }\n      // Fallback for 'HH' and 'H hour format with a `hour-range` in a 12-hour form\n      if (\n        (this.hourType === 'HH' || this.hourType === 'H') &&\n        +value === 0 && this.restrictedHourRange.includes(24)\n      ) {\n        return false\n      }\n      return !this.restrictedHourRange.includes(+value)\n    },\n\n    notInInterval (section, value) {\n      if (!section || !this.isMinuteOrSecond(section)) { return }\n      if (this.opts[`${section}Interval`] === 1) { return false }\n      return +value % this.opts[`${section}Interval`] !== 0\n    },\n\n    renderRangeList (rawRange, section) {\n      if (!rawRange || !section || !this.isMinuteOrSecond(section)) { return [] }\n      const range = [];\n      let formatedValue;\n      rawRange.forEach(value => {\n        if (value instanceof Array) {\n          if (value.length > 2 && this.debugMode) {\n            this.debugLog(`Nested array within \"${section}-range\" must contain no more than two items. Only the first two items of ${JSON.stringify(value)} will be taken into account.`);\n          }\n          const start = value[0];\n          const end = value[1] || value[0];\n          for (let i = +start; i <= +end; i++) {\n            if (i < 0 || i > 59) { continue }\n            formatedValue = this.formatValue(this.getTokenByType(section), i);\n            if (!range.includes(formatedValue)) {\n              range.push(formatedValue);\n            }\n          }\n        } else {\n          if (+value < 0 || +value > 59) { return }\n          formatedValue = this.formatValue(this.getTokenByType(section), value);\n          if (!range.includes(formatedValue)) {\n            range.push(formatedValue);\n          }\n        }\n      });\n      range.sort((l, r) => { return l - r });\n      // Debug Mode\n      if (this.debugMode) {\n        const fullList = (section === 'minute' ? this.minutes : this.seconds) || [];\n        const validItems = fullList.filter(item => range.includes(item));\n        if (!validItems || !validItems.length) {\n          if (section === 'minute') {\n            this.debugLog(`The minute list is empty due to the \"minute-range\" config\\nminute-range: ${JSON.stringify(this.minuteRange)}\\nminute-interval: ${this.opts.minuteInterval}`);\n          } else {\n            this.debugLog(`The second list is empty due to the \"second-range\" config\\nsecond-range: ${JSON.stringify(this.secondRange)}\\nsecond-interval: ${this.opts.secondInterval}`);\n          }\n        }\n      }\n      return range\n    },\n\n    forceApmSelection () {\n      if (this.manualInput) {\n        // Skip this to allow users to paste a string value from the clipboard in Manual Input mode\n        return\n      }\n      if (this.apmType && !this.apm) {\n        if (this.has.am || this.has.pm) {\n          this.doClearApmChecking = true;\n          const apmValue = this.has.am ? 'am' : 'pm';\n          this.apm = this.apmType === 'A' ? apmValue.toUpperCase() : apmValue;\n        }\n      }\n    },\n\n    emptyApmSelection () {\n      if (this.doClearApmChecking && this.hour === '' && this.minute === '' && this.second === '') {\n        this.apm = '';\n      }\n      this.doClearApmChecking = false;\n    },\n\n    apmDisplayText (apmValue) {\n      if (this.amText && this.lowerCasedApm(apmValue) === 'am') {\n        return this.amText\n      }\n      if (this.pmText && this.lowerCasedApm(apmValue) === 'pm') {\n        return this.pmText\n      }\n      return apmValue\n    },\n\n    toggleActive () {\n      if (this.disabled) { return }\n      this.isActive = !this.isActive;\n\n      if (this.isActive) {\n        this.isFocusing = true;\n        if (this.manualInput) {\n          this.$emit('focus');\n        }\n        if (!this.opts.hideDropdown) {\n          this.setDropdownState(true);\n        }\n        // Record to check if value did change in the later phase\n        if (this.lazy) {\n          this.bakDisplayTime = String(this.displayTime || '');\n        }\n        if (this.manualInput && !this.inputIsEmpty) {\n          nextTick(() => {\n            if (this.$refs.input && this.$refs.input.selectionStart === 0 && this.$refs.input.selectionEnd === this.displayTime.length) {\n              // Select the first slot instead of the whole value string when tabbed in\n              this.selectFirstSlot();\n            }\n          });\n        }\n      } else {\n        if (this.showDropdown) {\n          this.setDropdownState(false);\n        } else if (this.manualInput) {\n          this.$emit('blur');\n        }\n        this.isFocusing = false;\n        if (this.lazy) {\n          this.fillValues(true);\n          this.bakDisplayTime = undefined;\n        }\n      }\n\n      if (this.restrictedHourRange && this.baseOn12Hours) {\n        this.showDropdown ? this.forceApmSelection() : this.emptyApmSelection();\n      }\n      if (this.showDropdown) {\n        this.checkForAutoScroll();\n      }\n    },\n\n    setDropdownState (toShow, fromUserClick = false) {\n      if (toShow) {\n        this.keepFocusing();\n        if (this.autoDirectionEnabled) {\n          this.checkDropDirection();\n        }\n        this.showDropdown = true;\n        this.$emit('open'); \n        if (fromUserClick) {\n          if (this.fixedDropdownButton) {\n            this.isActive = true;\n          }\n          this.$emit('blur');\n          this.checkForAutoScroll();\n        }\n      } else {\n        this.showDropdown = false;\n        this.$emit('close');\n      }\n    },\n\n    blurEvent () {\n      if (this.manualInput && !this.opts.hideDropdown) {\n        // hideDropdown's `blur` event is handled somewhere else\n        this.$emit('blur');\n      }\n    },\n\n    select (type, value) {\n      if (this.isBasicType(type) && !this.isDisabled(type, value)) {\n        this[type] = value;\n        if (this.doClearApmChecking) {\n          this.doClearApmChecking = false;\n        }\n      }\n    },\n\n    clearTime () {\n      if (this.disabled) { return }\n      this.hour = '';\n      this.minute = '';\n      this.second = '';\n      this.apm = '';\n\n      if (this.manualInput && this.$refs && this.$refs.input && this.$refs.input.value.length) {\n        this.$refs.input.value = '';\n      }\n\n      if (this.lazy) {\n        this.fillValues(true);\n      }\n    },\n\n    //\n    // Auto-Scroll\n    //\n\n    checkForAutoScroll () {\n      if (this.inputIsEmpty) { return }\n      if (this.autoScroll) {\n        nextTick(() => {\n          this.scrollToSelectedValues();\n        });\n      } else if (this.advancedKeyboard) {\n        // Auto-focus on selected value in the first column for advanced-keyboard\n        nextTick(() => {\n          const firstColumn = this.inUse.types[0];\n          this.scrollToSelected(firstColumn, true);\n        });\n      }\n    },\n\n    scrollToSelected (column, allowFallback = false) {\n      if (!this.timeValue || this.inputIsEmpty) { return }\n      const targetList = this.$el.querySelectorAll(`ul.${column}s`)[0];\n      let targetValue = this.activeItemInCol(column)[0];\n      if (!targetValue && allowFallback) {\n        // No value selected in the target column, fallback to the first found valid item\n        targetValue = this.validItemsInCol(column)[0];\n      }\n      if (targetList && targetValue) {\n        targetList.scrollTop = targetValue.offsetTop || 0;\n        if (this.advancedKeyboard) {\n          targetValue.focus();\n        }\n      }\n    },\n\n    scrollToSelectedValues () {\n      if (!this.timeValue || this.inputIsEmpty) { return }\n      this.inUse.types.forEach(section => {\n        this.scrollToSelected(section);\n      });\n    },\n\n    //\n    // Additional Keyboard Navigation\n    //\n\n    onFocus () {\n      if (this.disabled) { return }\n      if (!this.isFocusing) {\n        this.isFocusing = true;\n      }\n      if (!this.isActive) {\n        this.toggleActive();\n      }\n    },\n\n    escBlur () {\n      if (this.disabled) { return }\n      window.clearTimeout(this.debounceTimer);\n      this.isFocusing = false;\n      const inputBox = this.$el.querySelectorAll('input.vue__time-picker-input')[0];\n      if (inputBox) {\n        inputBox.blur();\n      }\n    },\n\n    debounceBlur () {\n      if (this.disabled) { return }\n      this.isFocusing = false;\n      window.clearTimeout(this.debounceTimer);\n      this.debounceTimer = window.setTimeout(() => {\n        window.clearTimeout(this.debounceTimer);\n        this.onBlur();\n      }, this.opts.blurDelay);\n    },\n\n    onBlur () {\n      if (!this.disabled && !this.isFocusing && this.isActive) {\n        this.toggleActive();\n      }\n    },\n\n    keepFocusing () {\n      if (this.disabled) { return }\n      window.clearTimeout(this.debounceTimer);\n      if (!this.isFocusing) {\n        this.isFocusing = true;\n      }\n    },\n\n    validItemsInCol (column) {\n      const columnClass = `${column}s`;\n      return this.$el.querySelectorAll(`ul.${columnClass} > li:not(.hint):not([disabled])`)\n    },\n\n    activeItemInCol (column) {\n      const columnClass = `${column}s`;\n      return this.$el.querySelectorAll(`ul.${columnClass} > li.active:not(.hint)`)\n    },\n\n    getClosestSibling (column, dataKey, getPrevious = false) {\n      const siblingsInCol = this.validItemsInCol(column);\n      const selfIndex = Array.prototype.findIndex.call(siblingsInCol, (sbl) => {\n        return sbl.getAttribute('data-key') === dataKey\n      });\n\n      // Already the first item\n      if (getPrevious && selfIndex === 0) {\n        return siblingsInCol[siblingsInCol.length - 1]\n      }\n      // Already the last item\n      if (!getPrevious && selfIndex === siblingsInCol.length - 1) {\n        return siblingsInCol[0]\n      }\n      // Selected value not in the valid values list\n      if (selfIndex < 0) {\n        return siblingsInCol[0]\n      }\n\n      if (getPrevious) {\n        return siblingsInCol[selfIndex - 1]\n      }\n      return siblingsInCol[selfIndex + 1]\n    },\n\n    prevItem (column, dataKey, isManualInput = false) {\n      const targetItem = this.getClosestSibling(column, dataKey, true);\n      if (targetItem) {\n        return isManualInput ? targetItem : targetItem.focus()\n      }\n    },\n\n    nextItem (column, dataKey, isManualInput = false) {\n      const targetItem = this.getClosestSibling(column, dataKey, false);\n      if (targetItem) {\n        return isManualInput ? targetItem : targetItem.focus()\n      }\n    },\n\n    getSideColumnName (currentColumn, toLeft = false) {\n      const currentColumnIndex = this.inUse.types.indexOf(currentColumn);\n      if (toLeft && currentColumnIndex <= 0) {\n        if (this.debugMode) {\n          this.debugLog('You\\'re in the leftmost list already');\n        }\n        return\n      } else if (!toLeft && currentColumnIndex === (this.inUse.types.length - 1)) {\n        if (this.debugMode) {\n          this.debugLog('You\\'re in the rightmost list already');\n        }\n        return\n      }\n      return this.inUse.types[toLeft ? currentColumnIndex - 1 : currentColumnIndex + 1]\n    },\n\n    getFirstItemInSideColumn (currentColumn, toLeft = false) {\n      const targetColumn = this.getSideColumnName(currentColumn, toLeft);\n      if (!targetColumn) { return }\n      const listItems = this.validItemsInCol(targetColumn);\n      if (listItems && listItems[0]) {\n        return listItems[0]\n      }\n    },\n\n    getActiveItemInSideColumn (currentColumn, toLeft = false) {\n      const targetColumn = this.getSideColumnName(currentColumn, toLeft);\n      if (!targetColumn) { return }\n      const activeItems = this.activeItemInCol(targetColumn);\n      if (activeItems && activeItems[0]) {\n        return activeItems[0]\n      }\n    },\n\n    toLeftColumn (currentColumn) {\n      const targetItem = this.getActiveItemInSideColumn(currentColumn, true) || this.getFirstItemInSideColumn(currentColumn, true);\n      if (targetItem) {\n        targetItem.focus();\n      }\n    },\n\n    toRightColumn (currentColumn) {\n      const targetItem = this.getActiveItemInSideColumn(currentColumn, false) || this.getFirstItemInSideColumn(currentColumn, false);\n      if (targetItem) {\n        targetItem.focus();\n      }\n    },\n\n    //\n    // Manual Input\n    //\n\n    onMouseDown () {\n      if (!this.manualInput) { return }\n      window.clearTimeout(this.selectionTimer);\n      this.selectionTimer = window.setTimeout(() => {\n        window.clearTimeout(this.selectionTimer);\n        if (this.$refs && this.$refs.input) {\n          const nearestSlot = this.getNearestChunkByPos(this.$refs.input.selectionStart || 0);\n          this.debounceSetInputSelection(nearestSlot);\n        }\n      }, 50);\n    },\n\n    keyDownHandler (evt) {\n      if (evt.isComposing || evt.keyCode === 229) {\n        // Skip IME inputs\n        evt.preventDefault();\n        evt.stopPropagation();\n        return false\n      }\n      // Numbers\n      if ((evt.keyCode >= 48 && evt.keyCode <= 57) || (evt.keyCode >= 96 && evt.keyCode <= 105)) {\n        evt.preventDefault();\n        this.keyboardInput(evt.key);\n      // A|P|M\n      } else if ([65, 80, 77].includes(evt.keyCode)) {\n        evt.preventDefault();\n        this.keyboardInput(evt.key, true);\n      // Arrow keys\n      } else if (evt.keyCode >= 37 && evt.keyCode <= 40) {\n        evt.preventDefault();\n        this.clearKbInputLog();\n        this.arrowHandler(evt);\n      // Delete|Backspace\n      } else if (evt.keyCode === 8 || evt.keyCode === 46) {\n        evt.preventDefault();\n        this.clearKbInputLog();\n        this.clearTime();\n      // Tab\n      } else if (evt.keyCode === 9) {\n        this.clearKbInputLog();\n        this.tabHandler(evt);\n      // Prevent any Non-ESC and non-pasting inputs\n      } else if (evt.keyCode !== 27 && !(evt.metaKey || evt.ctrlKey)) {\n        evt.preventDefault();\n      }\n    },\n\n    onCompostionStart (evt) {\n      evt.preventDefault();\n      evt.stopPropagation();\n      this.bakCurrentPos = this.getCurrentTokenChunk();\n      return false\n    },\n\n    onCompostionEnd (evt) {\n      evt.preventDefault();\n      evt.stopPropagation();\n\n      const cpsData = evt.data;\n      let inputIsCustomApmText = false;\n      if (this.has.customApmText) {\n        inputIsCustomApmText = this.isCustomApmText(cpsData);\n      }\n      if (inputIsCustomApmText) {\n        this.setSanitizedValueToSection('apm', inputIsCustomApmText);\n      }\n\n      this.$refs.input.value = this.has.customApmText ? this.customDisplayTime : this.displayTime;\n\n      nextTick(() => {\n        if (this.bakCurrentPos) {\n          const bakPos = JSON.parse(JSON.stringify(this.bakCurrentPos));\n          if (inputIsCustomApmText) {\n            bakPos.end = (bakPos.start + cpsData.length);\n          }\n          this.debounceSetInputSelection(bakPos);\n          this.bakCurrentPos = null;\n        }\n      });\n      return false\n    },\n\n    pasteHandler (evt) {\n      evt.preventDefault();\n      let pastingText = (evt.clipboardData || window.clipboardData).getData('text');\n      if (this.debugMode) {\n        this.debugLog(`Pasting value \"${pastingText}\" from clipboard`);\n      }\n      if (!pastingText || !pastingText.length) { return }\n\n      // Replace custom AM/PM text (if any)\n      if (this.has.customApmText) {\n        pastingText = this.replaceCustomApmText(pastingText);\n      }\n\n      if (this.inputIsEmpty) {\n        this.readStringValues(pastingText);\n      } else {\n        this.kbInputLog = pastingText.substr(-2, 2);\n        this.setKbInput();\n        this.debounceClearKbLog();\n      }\n    },\n\n    arrowHandler (evt) {\n      const direction = { 37: 'L', 38: 'U', 39: 'R', 40: 'D' }[evt.keyCode];\n      if (direction === 'U' || direction === 'D') {\n        if (this.inputIsEmpty) {\n          this.selectFirstValidValue();\n        } else {\n          const currentChunk = this.getCurrentTokenChunk();\n          if (!currentChunk) {\n            this.selectFirstValidValue();\n            return\n          }\n          const tokenType = currentChunk.type;\n          this.getClosestValidItemInCol(tokenType, this[tokenType], direction);\n          const newChunkPos = this.getCurrentTokenChunk();\n          this.debounceSetInputSelection(newChunkPos);\n        }\n      } else if (direction === 'R') {\n        this.toLateralToken(false);\n      } else if (direction === 'L') {\n        this.toLateralToken(true);\n      }\n    },\n\n    tabHandler (evt) {      \n      if (!this.inputIsEmpty && this.tokenChunksPos && this.tokenChunksPos.length) {\n        const currentChunk = this.getCurrentTokenChunk();\n        if (!currentChunk) { return }\n        const firstChunk = this.tokenChunksPos[0];\n        const lastChunk = this.tokenChunksPos[this.tokenChunksPos.length - 1];\n        if ((evt.shiftKey && currentChunk.token !== firstChunk.token) || (!evt.shiftKey && currentChunk.token !== lastChunk.token)) {\n          evt.preventDefault();\n          this.toLateralToken(evt.shiftKey);\n        }\n      }\n    },\n\n    keyboardInput (newChar, isApm = false) {\n      const currentChunk = this.getCurrentTokenChunk();\n      if (!currentChunk || (currentChunk.type !== 'apm' && isApm) || (currentChunk.type === 'apm' && !isApm)) { return }\n      this.kbInputLog = `${this.kbInputLog.substr(-1)}${newChar}`;\n      this.setKbInput();\n      this.debounceClearKbLog();\n    },\n\n    clearKbInputLog () {\n      window.clearTimeout(this.kbInputTimer);\n      this.kbInputLog = '';\n    },\n\n    debounceClearKbLog () {\n      window.clearTimeout(this.kbInputTimer);\n      this.kbInputTimer = window.setTimeout(() => {\n        this.clearKbInputLog();\n      }, this.opts.manualInputTimeout);\n    },\n\n    setKbInput (value) {\n      value = value || this.kbInputLog;\n      const currentChunk = this.getCurrentTokenChunk();\n      if (!currentChunk || !value || !value.length) { return }\n      const chunkType = currentChunk.type;\n      const chunkToken = currentChunk.token;\n\n      let validValue;\n      if (chunkType === 'apm') {\n        if (this.lowerCasedApm(value).includes('a')) {\n          validValue = 'am';\n        } else if (this.lowerCasedApm(value).includes('p')) {\n          validValue = 'pm';\n        }\n        if (validValue) {\n          validValue = chunkToken === 'A' ? validValue.toUpperCase() : validValue;\n        }\n      } else {\n        if (this.isValidValue(chunkToken, value)) {\n          validValue = value;\n        } else {\n          const lastInputValue = this.formatValue(chunkToken, value.substr(-1));\n          if (this.isValidValue(chunkToken, lastInputValue)) {\n            validValue = lastInputValue;\n          }\n        }\n      }\n\n      if (validValue) {\n        this.setSanitizedValueToSection(chunkType, validValue);\n        const newChunkPos = this.getCurrentTokenChunk();\n        this.debounceSetInputSelection(newChunkPos);      \n      }\n      if (this.debugMode) {\n        if (validValue) {\n          this.debugLog(`Successfully set value \"${validValue}\" from latest input \"${value}\" for the \"${chunkType}\" slot`);\n        } else {\n          this.debugLog(`Value \"${value}\" is invalid in the \"${chunkType}\" slot`);\n        }\n      }\n    },\n\n    // Form Autofill\n    onChange () {\n      if (!this.manualInput || !this.$refs || !this.$refs.input) { return }\n      const autoFillValue = this.$refs.input.value || '';\n      if (autoFillValue && autoFillValue.length) {\n        this.readStringValues(autoFillValue);\n      }\n    },\n\n    getNearestChunkByPos (startPos) {\n      if (!this.tokenChunksPos || !this.tokenChunksPos.length) { return }\n      let nearest;\n      let nearestDelta = -1;\n      for (let i = 0; i < this.tokenChunksPos.length; i++) {\n        const chunk = JSON.parse(JSON.stringify(this.tokenChunksPos[i]));\n        if (chunk.start === startPos) {\n          return chunk\n        }\n        const delta = Math.abs(chunk.start - startPos);\n        if (nearestDelta < 0) {\n          nearest = chunk;\n          nearestDelta = delta;\n        } else {\n          if (nearestDelta <= delta) {\n            return nearest\n          }\n          nearestDelta = delta;\n          nearest = chunk;\n        }\n      }\n      return nearest\n    },\n\n    selectFirstValidValue () {\n      if (!this.tokenChunksPos || !this.tokenChunksPos.length) { return }\n      const firstSlotType = this.tokenChunksPos[0].type;\n      if (firstSlotType === 'hour') {\n        this.getClosestHourItem();\n      } else {\n        this.getClosestValidItemInCol(firstSlotType, this[firstSlotType]);\n      }\n      this.selectFirstSlot();\n    },\n\n    getClosestHourItem (currentValue, direction = 'U') {\n      if (!this.validHoursList || !this.validHoursList.length) {\n        if (this.debugMode) {\n          this.debugLog(`No valid hour values found, please check your \"hour-range\" config\\nhour-range: ${JSON.stringify(this.hourRange)}`);\n        }\n        return\n      }\n      if (!currentValue) {\n        this.setManualHour(this.validHoursList[0]);\n        return\n      }\n      const currentIndex = this.validHoursList.findIndex(item => {\n        if (!this.baseOn12Hours) {\n          return item === currentValue\n        } else {\n          const valueKey = `${currentValue}${this.lowerCasedApm(this.apm) === 'pm' ? 'p' : 'a'}`; \n          return item === valueKey\n        }\n      });\n      let nextIndex;\n      if (currentIndex === -1) {\n        nextIndex = 0;\n      } else if (direction === 'D') {\n        nextIndex = currentIndex === 0 ? this.validHoursList.length - 1 : currentIndex - 1;\n      } else {\n        nextIndex = (currentIndex + 1) % this.validHoursList.length;\n      }\n      const nextItem = this.validHoursList[nextIndex];\n      this.setManualHour(nextItem);\n    },\n\n    getClosestValidItemInCol (column, currentValue, direction = 'U') {\n      if (column === 'hour') {\n        this.getClosestHourItem(currentValue, direction);\n      } else {\n        const nextItem = direction === 'D' ? this.prevItem(column, this[column], true) : this.nextItem(column, this[column], true);\n        if (nextItem) {\n          this.select(column, nextItem.getAttribute('data-key'));\n        }\n      }\n    },\n\n    setSanitizedValueToSection (section, inputValue) {\n      if (!section || !this.getTokenByType(section)) { return }\n      // NOTE: Disabled values are allowed here, followed by an 'error' event, though\n      const sanitizedValue = this.sanitizedValue(this.getTokenByType(section), inputValue);\n      this[section] = sanitizedValue;\n    },\n\n    setManualHour (nextItem) {\n      if (this.is12hRange(nextItem)) {\n        const hourT = this.match12hRange(nextItem);\n        const apmValue = hourT[2] === 'a' ? 'AM' : 'PM';\n        this.setSanitizedValueToSection('apm', this.apmType === 'a' ? apmValue.toLowerCase() : apmValue);\n        this.setSanitizedValueToSection('hour', hourT[1]);\n      } else {\n        this.setSanitizedValueToSection('hour', nextItem);\n      }\n    },\n\n    debounceSetInputSelection ({start = 0, end = 0 }) {\n      nextTick(() => {\n        this.setInputSelectionRange(start, end);\n      });\n      window.clearTimeout(this.selectionTimer);\n      this.selectionTimer = window.setTimeout(() => {\n        window.clearTimeout(this.selectionTimer);\n        // Double-check selection for 12hr format\n        if (this.$refs.input && (this.$refs.input.selectionStart !== start || this.$refs.input.selectionEnd !== end)) {\n          this.setInputSelectionRange(start, end);\n        }\n      }, 30);\n    },\n\n    setInputSelectionRange (start, end) {\n      if (this.$refs && this.$refs.input) {\n        this.$refs.input.setSelectionRange(start, end);\n      }\n    },\n\n    getCurrentTokenChunk () {\n      return this.getNearestChunkByPos((this.$refs.input && this.$refs.input.selectionStart) || 0)\n    },\n\n    selectFirstSlot () {\n      const firstChunkPos = this.getNearestChunkByPos(0);\n      this.debounceSetInputSelection(firstChunkPos);\n    },\n\n    toLateralToken (toLeft) {\n      const currentChunk = this.getCurrentTokenChunk();\n      if (!currentChunk) {\n        this.selectFirstValidValue();\n        return\n      }\n      const currentChunkIndex = this.tokenChunksPos.findIndex(chk => chk.token === currentChunk.token);\n      if ((!toLeft && currentChunkIndex >= this.tokenChunksPos.length - 1) || (toLeft && currentChunkIndex === 0)) {\n        if (this.debugMode) {\n          if (toLeft) {\n            this.debugLog('You\\'re in the leftmost slot already');\n          } else {\n            this.debugLog('You\\'re in the rightmost slot already');\n          }\n        }\n        return\n      }\n      const targetSlotPos = toLeft ? this.tokenChunksPos[currentChunkIndex - 1] : this.tokenChunksPos[currentChunkIndex + 1];\n      this.debounceSetInputSelection(targetSlotPos);\n    },\n\n    isCustomApmText (inputData) {\n      if (!inputData || !inputData.length) { return false }\n      if (this.amText && this.amText === inputData) {\n        return this.apmType === 'A' ? 'AM' : 'am'\n      }\n      if (this.pmText && this.pmText === inputData) {\n        return this.apmType === 'A' ? 'PM' : 'pm'\n      }\n      return false\n    },\n\n    replaceCustomApmText (inputString) {\n      if (this.amText && this.amText.length && inputString.includes(this.amText)) {\n        return inputString.replace(new RegExp(this.amText, 'g'), this.apmType === 'A' ? 'AM' : 'am')\n      } else if (this.pmText && this.pmText.length && inputString.includes(this.pmText)) {\n        return inputString.replace(new RegExp(this.pmText, 'g'), this.apmType === 'A' ? 'PM' : 'pm')\n      }\n      return inputString\n    },\n\n    checkDropDirection () {\n      if (!this.$el) { return }\n      let container;\n      if (this.containerId && this.containerId.length) {\n        container = document.getElementById(this.containerId);\n        if (!container && this.debugMode) {\n          this.debugLog(`Container with id \"${this.containerId}\" not found. Fallback to document body.`);\n        }\n      }\n      const el = this.$el;\n      let spaceDown;\n      if (container && container.offsetHeight) {\n        // Valid container found\n        spaceDown = (container.offsetTop + container.offsetHeight) - (el.offsetTop + el.offsetHeight);\n      } else {\n        // Fallback to document body\n        const docHeight = Math.max(document.body.scrollHeight, document.documentElement.scrollHeight, document.body.offsetHeight, document.documentElement.offsetHeight, document.body.clientHeight, document.documentElement.clientHeight);\n        spaceDown = docHeight - (el.offsetTop + el.offsetHeight);\n      }\n      this.forceDropOnTop = this.opts.dropOffsetHeight > spaceDown;\n    },\n\n    //\n    // Helpers\n    //\n\n    is12hRange (value) {\n      return /^\\d{1,2}(a|p|A|P)$/.test(value)\n    },\n\n    match12hRange (value) {\n      return value.match(/^(\\d{1,2})(a|p|A|P)$/)\n    },\n\n    isNumber (value) {\n      return !isNaN(parseFloat(value)) && isFinite(value)\n    },\n\n    isBasicType (type) {\n      return CONFIG.BASIC_TYPES.includes(type)\n    },\n\n    lowerCasedApm (apmValue) {\n      return (apmValue || '').toLowerCase()\n    },\n\n    getTokenRegex (token) {\n      switch (token) {\n        case 'HH':\n          return '([01][0-9]|2[0-3]|H{2})'\n        case 'H':\n          return '([0-9]{1}|1[0-9]|2[0-3]|H{1})'\n        case 'hh':\n          return '(0[1-9]|1[0-2]|h{2})'\n        case 'h':\n          return '([1-9]{1}|1[0-2]|h{1})'\n        case 'kk':\n          return '(0[1-9]|1[0-9]|2[0-4]|k{2})'\n        case 'k':\n          return '([1-9]{1}|1[0-9]|2[0-4]|k{1})'\n        case 'mm':\n          return '([0-5][0-9]|m{2})'\n        case 'ss':\n          return '([0-5][0-9]|s{2})'\n        case 'm':\n          return '([0-9]{1}|[1-5][0-9]|m{1})'\n        case 's':\n          return '([0-9]{1}|[1-5][0-9]|s{1})'\n        case 'A':\n          return '(AM|PM|A{1})'\n        case 'a':\n          return '(am|pm|a{1})'\n        default:\n          return ''\n      }\n    },\n\n    isEmptyValue (targetToken, testValue) {\n      return (!testValue || !testValue.length) || (testValue && testValue === targetToken)\n    },\n\n    isValidValue (targetToken, testValue) {\n      if (!targetToken || this.isEmptyValue(targetToken, testValue)) { return false }\n      const tokenRegexStr = this.getTokenRegex(targetToken);\n      if (!tokenRegexStr || !tokenRegexStr.length) { return false }\n      return (new RegExp(`^${tokenRegexStr}$`)).test(testValue)\n    },\n\n    sanitizedValue (targetToken, inputValue) {\n      if (this.isValidValue(targetToken, inputValue)) {\n        return inputValue\n      }\n      return ''\n    },\n\n    getTokenType (token) {\n      return this.inUse.types[this.inUse.tokens.indexOf(token)] || ''\n    },\n\n    getTokenByType (type) {\n      return this[`${type}Type`] || ''\n    },\n\n    isMinuteOrSecond (type) {\n      return ['minute', 'second'].includes(type)\n    },\n\n    // Breaking attribution coercion changes in Vue 3\n    // > https://v3.vuejs.org/guide/migration/attribute-coercion.html#overview\n    booleanAttr (isTrue = false) {\n      return isTrue ? true : null\n    },\n\n    debugLog (logText) {\n      if (!logText || !logText.length) { return }\n      let identifier = '';\n      if (this.id) {\n        identifier += `#${this.id}`;\n      }\n      if (this.name) {\n        identifier += `[name=${this.name}]`;\n      }\n      if (this.inputClass) {\n        let inputClasses = [];\n        if (typeof this.inputClass === 'string') {\n          inputClasses = this.inputClass.split(/\\s/g);\n        } else if (Array.isArray(this.inputClass)) {\n          inputClasses = [].concat([], this.inputClass);\n        } else if (typeof this.inputClass === 'object') {\n          Object.keys(this.inputClass).forEach(clsName => {\n            if (this.inputClass[clsName]) {\n              inputClasses.push(clsName);\n            }\n          });\n        }\n        for (let inputClass of inputClasses) {\n          if (inputClass && inputClass.trim().length) {\n            identifier += `.${inputClass.trim()}`;\n          }\n        }\n      }\n      const finalLogText = `DEBUG: ${logText}${identifier ? `\\n\\t(${identifier})` : '' }`;\n      if (window.console.debug && typeof window.console.debug === 'function') {\n        window.console.debug(finalLogText);\n      } else {\n        window.console.log(finalLogText);\n      }\n    }\n  },\n\n  mounted () {\n    window.clearTimeout(this.debounceTimer);\n    window.clearTimeout(this.selectionTimer);\n    window.clearTimeout(this.kbInputTimer);\n    this.renderFormat();\n  },\n\n  beforeUnmount () {\n    window.clearTimeout(this.debounceTimer);\n    window.clearTimeout(this.selectionTimer);\n    window.clearTimeout(this.kbInputTimer);\n  }\n};\n\nconst _hoisted_1 = {\n  key: 0,\n  class: \"controls\",\n  tabindex: \"-1\"\n};\nconst _hoisted_2 = /*#__PURE__*/createVNode(\"span\", { class: \"char\" }, \"×\", -1 /* HOISTED */);\nconst _hoisted_3 = /*#__PURE__*/createVNode(\"span\", { class: \"char\" }, \"▾\", -1 /* HOISTED */);\nconst _hoisted_4 = {\n  key: 1,\n  class: \"custom-icon\"\n};\n\nfunction render(_ctx, _cache, $props, $setup, $data, $options) {\n  return (openBlock(), createBlock(\"span\", {\n    class: \"vue__time-picker\",\n    style: $options.inputWidthStyle\n  }, [\n    createVNode(\"input\", {\n      type: \"text\",\n      class: [\"vue__time-picker-input\", [$props.inputClass, {'is-empty': $options.inputIsEmpty, 'invalid': $options.hasInvalidInput, 'all-selected': $options.allValueSelected, 'disabled': $props.disabled, 'has-custom-icon': _ctx.$slots && _ctx.$slots.icon }]],\n      ref: \"input\",\n      style: $options.inputWidthStyle,\n      id: $props.id,\n      name: $props.name,\n      value: $options.inputIsEmpty ? null : $options.customDisplayTime,\n      placeholder: $props.placeholder ? $props.placeholder : $options.formatString,\n      tabindex: $props.disabled ? -1 : $props.tabindex,\n      disabled: $options.booleanAttr($props.disabled),\n      readonly: $options.booleanAttr(!$props.manualInput),\n      autocomplete: $props.autocomplete,\n      onFocus: _cache[1] || (_cache[1] = (...args) => ($options.onFocus(...args))),\n      onChange: _cache[2] || (_cache[2] = (...args) => ($options.onChange(...args))),\n      onBlur: _cache[3] || (_cache[3] = $event => {$options.debounceBlur(); $options.blurEvent();}),\n      onMousedown: _cache[4] || (_cache[4] = (...args) => ($options.onMouseDown(...args))),\n      onKeydown: [\n        _cache[5] || (_cache[5] = (...args) => ($options.keyDownHandler(...args))),\n        _cache[9] || (_cache[9] = withKeys(withModifiers((...args) => ($options.escBlur(...args)), [\"exact\"]), [\"esc\"]))\n      ],\n      onCompositionstart: _cache[6] || (_cache[6] = (...args) => ($options.onCompostionStart(...args))),\n      onCompositionend: _cache[7] || (_cache[7] = (...args) => ($options.onCompostionEnd(...args))),\n      onPaste: _cache[8] || (_cache[8] = (...args) => ($options.pasteHandler(...args)))\n    }, null, 46 /* CLASS, STYLE, PROPS, HYDRATE_EVENTS */, [\"id\", \"name\", \"value\", \"placeholder\", \"tabindex\", \"disabled\", \"readonly\", \"autocomplete\"]),\n    ($options.showClearBtn || $options.showDropdownBtn)\n      ? (openBlock(), createBlock(\"div\", _hoisted_1, [\n          (!$data.isActive && $options.showClearBtn)\n            ? (openBlock(), createBlock(\"span\", {\n                key: 0,\n                class: [\"clear-btn\", {'has-custom-btn': _ctx.$slots && _ctx.$slots.clearButton }],\n                tabindex: \"-1\",\n                onClick: _cache[10] || (_cache[10] = (...args) => ($options.clearTime(...args)))\n              }, [\n                renderSlot(_ctx.$slots, \"clearButton\", {}, () => [\n                  _hoisted_2\n                ])\n              ], 2 /* CLASS */))\n            : createCommentVNode(\"v-if\", true),\n          ($options.showDropdownBtn)\n            ? (openBlock(), createBlock(\"span\", {\n                key: 1,\n                class: [\"dropdown-btn\", {'has-custom-btn': _ctx.$slots && _ctx.$slots.dropdownButton }],\n                tabindex: \"-1\",\n                onClick: _cache[11] || (_cache[11] = $event => ($options.setDropdownState($props.fixedDropdownButton ? !$data.showDropdown : true, true))),\n                onMousedown: _cache[12] || (_cache[12] = (...args) => ($options.keepFocusing(...args)))\n              }, [\n                renderSlot(_ctx.$slots, \"dropdownButton\", {}, () => [\n                  _hoisted_3\n                ])\n              ], 34 /* CLASS, HYDRATE_EVENTS */))\n            : createCommentVNode(\"v-if\", true)\n        ]))\n      : createCommentVNode(\"v-if\", true),\n    (_ctx.$slots && _ctx.$slots.icon)\n      ? (openBlock(), createBlock(\"div\", _hoisted_4, [\n          renderSlot(_ctx.$slots, \"icon\")\n        ]))\n      : createCommentVNode(\"v-if\", true),\n    ($data.showDropdown)\n      ? (openBlock(), createBlock(\"div\", {\n          key: 2,\n          class: \"time-picker-overlay\",\n          onClick: _cache[13] || (_cache[13] = (...args) => ($options.toggleActive(...args))),\n          tabindex: \"-1\"\n        }))\n      : createCommentVNode(\"v-if\", true),\n    withDirectives(createVNode(\"div\", {\n      class: [\"dropdown\", [$options.dropdownDirClass]],\n      tabindex: \"-1\",\n      style: $options.inputWidthStyle,\n      onMouseup: _cache[42] || (_cache[42] = (...args) => ($options.keepFocusing(...args))),\n      onClick: _cache[43] || (_cache[43] = withModifiers(() => {}, [\"stop\"]))\n    }, [\n      createVNode(\"div\", {\n        class: \"select-list\",\n        style: $options.inputWidthStyle,\n        tabindex: \"-1\"\n      }, [\n        createCommentVNode(\" Common Keyboard Support: less event listeners \"),\n        (!$props.advancedKeyboard)\n          ? (openBlock(true), createBlock(Fragment, { key: 0 }, renderList($options.columnsSequence, (column) => {\n              return (openBlock(), createBlock(Fragment, { key: column }, [\n                (column === 'hour')\n                  ? (openBlock(), createBlock(\"ul\", {\n                      key: 0,\n                      class: \"hours\",\n                      onScroll: _cache[14] || (_cache[14] = (...args) => ($options.keepFocusing(...args)))\n                    }, [\n                      createVNode(\"li\", {\n                        class: \"hint\",\n                        textContent: toDisplayString($options.hourLabelText)\n                      }, null, 8 /* PROPS */, [\"textContent\"]),\n                      (openBlock(true), createBlock(Fragment, null, renderList($data.hours, (hr, hIndex) => {\n                        return (openBlock(), createBlock(Fragment, { key: hIndex }, [\n                          (!$options.opts.hideDisabledHours || ($options.opts.hideDisabledHours && !$options.isDisabled('hour', hr)))\n                            ? (openBlock(), createBlock(\"li\", {\n                                key: 0,\n                                class: {active: $data.hour === hr},\n                                disabled: $options.booleanAttr($options.isDisabled('hour', hr)),\n                                \"data-key\": hr,\n                                textContent: toDisplayString(hr),\n                                onClick: $event => ($options.select('hour', hr))\n                              }, null, 10 /* CLASS, PROPS */, [\"disabled\", \"data-key\", \"textContent\", \"onClick\"]))\n                            : createCommentVNode(\"v-if\", true)\n                        ], 64 /* STABLE_FRAGMENT */))\n                      }), 128 /* KEYED_FRAGMENT */))\n                    ], 32 /* HYDRATE_EVENTS */))\n                  : createCommentVNode(\"v-if\", true),\n                (column === 'minute')\n                  ? (openBlock(), createBlock(\"ul\", {\n                      key: 1,\n                      class: \"minutes\",\n                      onScroll: _cache[15] || (_cache[15] = (...args) => ($options.keepFocusing(...args)))\n                    }, [\n                      createVNode(\"li\", {\n                        class: \"hint\",\n                        textContent: toDisplayString($options.minuteLabelText)\n                      }, null, 8 /* PROPS */, [\"textContent\"]),\n                      (openBlock(true), createBlock(Fragment, null, renderList($data.minutes, (m, mIndex) => {\n                        return (openBlock(), createBlock(Fragment, { key: mIndex }, [\n                          (!$options.opts.hideDisabledMinutes || ($options.opts.hideDisabledMinutes && !$options.isDisabled('minute', m)))\n                            ? (openBlock(), createBlock(\"li\", {\n                                key: 0,\n                                class: {active: $data.minute === m},\n                                disabled: $options.booleanAttr($options.isDisabled('minute', m)),\n                                \"data-key\": m,\n                                textContent: toDisplayString(m),\n                                onClick: $event => ($options.select('minute', m))\n                              }, null, 10 /* CLASS, PROPS */, [\"disabled\", \"data-key\", \"textContent\", \"onClick\"]))\n                            : createCommentVNode(\"v-if\", true)\n                        ], 64 /* STABLE_FRAGMENT */))\n                      }), 128 /* KEYED_FRAGMENT */))\n                    ], 32 /* HYDRATE_EVENTS */))\n                  : createCommentVNode(\"v-if\", true),\n                (column === 'second')\n                  ? (openBlock(), createBlock(\"ul\", {\n                      key: 2,\n                      class: \"seconds\",\n                      onScroll: _cache[16] || (_cache[16] = (...args) => ($options.keepFocusing(...args)))\n                    }, [\n                      createVNode(\"li\", {\n                        class: \"hint\",\n                        textContent: toDisplayString($options.secondLabelText)\n                      }, null, 8 /* PROPS */, [\"textContent\"]),\n                      (openBlock(true), createBlock(Fragment, null, renderList($data.seconds, (s, sIndex) => {\n                        return (openBlock(), createBlock(Fragment, { key: sIndex }, [\n                          (!$options.opts.hideDisabledSeconds || ($options.opts.hideDisabledSeconds && !$options.isDisabled('second', s)))\n                            ? (openBlock(), createBlock(\"li\", {\n                                key: 0,\n                                class: {active: $data.second === s},\n                                disabled: $options.booleanAttr($options.isDisabled('second', s)),\n                                \"data-key\": s,\n                                textContent: toDisplayString(s),\n                                onClick: $event => ($options.select('second', s))\n                              }, null, 10 /* CLASS, PROPS */, [\"disabled\", \"data-key\", \"textContent\", \"onClick\"]))\n                            : createCommentVNode(\"v-if\", true)\n                        ], 64 /* STABLE_FRAGMENT */))\n                      }), 128 /* KEYED_FRAGMENT */))\n                    ], 32 /* HYDRATE_EVENTS */))\n                  : createCommentVNode(\"v-if\", true),\n                (column === 'apm')\n                  ? (openBlock(), createBlock(\"ul\", {\n                      key: 3,\n                      class: \"apms\",\n                      onScroll: _cache[17] || (_cache[17] = (...args) => ($options.keepFocusing(...args)))\n                    }, [\n                      createVNode(\"li\", {\n                        class: \"hint\",\n                        textContent: toDisplayString($options.apmLabelText)\n                      }, null, 8 /* PROPS */, [\"textContent\"]),\n                      (openBlock(true), createBlock(Fragment, null, renderList($data.apms, (a, aIndex) => {\n                        return (openBlock(), createBlock(Fragment, { key: aIndex }, [\n                          (!$options.opts.hideDisabledHours || ($options.opts.hideDisabledHours && !$options.isDisabled('apm', a)))\n                            ? (openBlock(), createBlock(\"li\", {\n                                key: 0,\n                                class: {active: $data.apm === a},\n                                disabled: $options.booleanAttr($options.isDisabled('apm', a)),\n                                \"data-key\": a,\n                                textContent: toDisplayString($options.apmDisplayText(a)),\n                                onClick: $event => ($options.select('apm', a))\n                              }, null, 10 /* CLASS, PROPS */, [\"disabled\", \"data-key\", \"textContent\", \"onClick\"]))\n                            : createCommentVNode(\"v-if\", true)\n                        ], 64 /* STABLE_FRAGMENT */))\n                      }), 128 /* KEYED_FRAGMENT */))\n                    ], 32 /* HYDRATE_EVENTS */))\n                  : createCommentVNode(\"v-if\", true)\n              ], 64 /* STABLE_FRAGMENT */))\n            }), 128 /* KEYED_FRAGMENT */))\n          : createCommentVNode(\"v-if\", true),\n        createCommentVNode(\" / Common Keyboard Support \"),\n        createCommentVNode(\"\\n        Advanced Keyboard Support\\n        Addeds hundreds of additional event lisenters\\n      \"),\n        ($props.advancedKeyboard)\n          ? (openBlock(true), createBlock(Fragment, { key: 1 }, renderList($options.columnsSequence, (column) => {\n              return (openBlock(), createBlock(Fragment, { key: column }, [\n                (column === 'hour')\n                  ? (openBlock(), createBlock(\"ul\", {\n                      key: 0,\n                      class: \"hours\",\n                      tabindex: \"-1\",\n                      onScroll: _cache[23] || (_cache[23] = (...args) => ($options.keepFocusing(...args)))\n                    }, [\n                      createVNode(\"li\", {\n                        class: \"hint\",\n                        textContent: toDisplayString($options.hourLabelText),\n                        tabindex: \"-1\"\n                      }, null, 8 /* PROPS */, [\"textContent\"]),\n                      (openBlock(true), createBlock(Fragment, null, renderList($data.hours, (hr, hIndex) => {\n                        return (openBlock(), createBlock(Fragment, { key: hIndex }, [\n                          (!$options.opts.hideDisabledHours || ($options.opts.hideDisabledHours && !$options.isDisabled('hour', hr)))\n                            ? (openBlock(), createBlock(\"li\", {\n                                key: 0,\n                                class: {active: $data.hour === hr},\n                                tabindex: $options.isDisabled('hour', hr) ? -1 : $props.tabindex,\n                                \"data-key\": hr,\n                                disabled: $options.booleanAttr($options.isDisabled('hour', hr)),\n                                textContent: toDisplayString(hr),\n                                onClick: $event => ($options.select('hour', hr)),\n                                onKeydown: [\n                                  withKeys(withModifiers($event => ($options.select('hour', hr)), [\"prevent\"]), [\"space\"]),\n                                  withKeys(withModifiers($event => ($options.select('hour', hr)), [\"prevent\"]), [\"enter\"]),\n                                  withKeys(withModifiers($event => ($options.prevItem('hour', hr)), [\"prevent\"]), [\"up\"]),\n                                  withKeys(withModifiers($event => ($options.nextItem('hour', hr)), [\"prevent\"]), [\"down\"]),\n                                  _cache[18] || (_cache[18] = withKeys(withModifiers($event => ($options.toLeftColumn('hour')), [\"prevent\"]), [\"left\"])),\n                                  _cache[19] || (_cache[19] = withKeys(withModifiers($event => ($options.toRightColumn('hour')), [\"prevent\"]), [\"right\"])),\n                                  _cache[20] || (_cache[20] = withKeys(withModifiers((...args) => ($options.debounceBlur(...args)), [\"exact\"]), [\"esc\"]))\n                                ],\n                                onBlur: _cache[21] || (_cache[21] = (...args) => ($options.debounceBlur(...args))),\n                                onFocus: _cache[22] || (_cache[22] = (...args) => ($options.keepFocusing(...args)))\n                              }, null, 42 /* CLASS, PROPS, HYDRATE_EVENTS */, [\"tabindex\", \"data-key\", \"disabled\", \"textContent\", \"onClick\", \"onKeydown\"]))\n                            : createCommentVNode(\"v-if\", true)\n                        ], 64 /* STABLE_FRAGMENT */))\n                      }), 128 /* KEYED_FRAGMENT */))\n                    ], 32 /* HYDRATE_EVENTS */))\n                  : createCommentVNode(\"v-if\", true),\n                (column === 'minute')\n                  ? (openBlock(), createBlock(\"ul\", {\n                      key: 1,\n                      class: \"minutes\",\n                      tabindex: \"-1\",\n                      onScroll: _cache[29] || (_cache[29] = (...args) => ($options.keepFocusing(...args)))\n                    }, [\n                      createVNode(\"li\", {\n                        class: \"hint\",\n                        textContent: toDisplayString($options.minuteLabelText),\n                        tabindex: \"-1\"\n                      }, null, 8 /* PROPS */, [\"textContent\"]),\n                      (openBlock(true), createBlock(Fragment, null, renderList($data.minutes, (m, mIndex) => {\n                        return (openBlock(), createBlock(Fragment, { key: mIndex }, [\n                          (!$options.opts.hideDisabledMinutes || ($options.opts.hideDisabledMinutes && !$options.isDisabled('minute', m)))\n                            ? (openBlock(), createBlock(\"li\", {\n                                key: 0,\n                                class: {active: $data.minute === m},\n                                tabindex: $options.isDisabled('minute', m) ? -1 : $props.tabindex,\n                                \"data-key\": m,\n                                disabled: $options.booleanAttr($options.isDisabled('minute', m)),\n                                textContent: toDisplayString(m),\n                                onClick: $event => ($options.select('minute', m)),\n                                onKeydown: [\n                                  withKeys(withModifiers($event => ($options.select('minute', m)), [\"prevent\"]), [\"space\"]),\n                                  withKeys(withModifiers($event => ($options.select('minute', m)), [\"prevent\"]), [\"enter\"]),\n                                  withKeys(withModifiers($event => ($options.prevItem('minute', m)), [\"prevent\"]), [\"up\"]),\n                                  withKeys(withModifiers($event => ($options.nextItem('minute', m)), [\"prevent\"]), [\"down\"]),\n                                  _cache[24] || (_cache[24] = withKeys(withModifiers($event => ($options.toLeftColumn('minute')), [\"prevent\"]), [\"left\"])),\n                                  _cache[25] || (_cache[25] = withKeys(withModifiers($event => ($options.toRightColumn('minute')), [\"prevent\"]), [\"right\"])),\n                                  _cache[26] || (_cache[26] = withKeys(withModifiers((...args) => ($options.debounceBlur(...args)), [\"exact\"]), [\"esc\"]))\n                                ],\n                                onBlur: _cache[27] || (_cache[27] = (...args) => ($options.debounceBlur(...args))),\n                                onFocus: _cache[28] || (_cache[28] = (...args) => ($options.keepFocusing(...args)))\n                              }, null, 42 /* CLASS, PROPS, HYDRATE_EVENTS */, [\"tabindex\", \"data-key\", \"disabled\", \"textContent\", \"onClick\", \"onKeydown\"]))\n                            : createCommentVNode(\"v-if\", true)\n                        ], 64 /* STABLE_FRAGMENT */))\n                      }), 128 /* KEYED_FRAGMENT */))\n                    ], 32 /* HYDRATE_EVENTS */))\n                  : createCommentVNode(\"v-if\", true),\n                (column === 'second')\n                  ? (openBlock(), createBlock(\"ul\", {\n                      key: 2,\n                      class: \"seconds\",\n                      tabindex: \"-1\",\n                      onScroll: _cache[35] || (_cache[35] = (...args) => ($options.keepFocusing(...args)))\n                    }, [\n                      createVNode(\"li\", {\n                        class: \"hint\",\n                        textContent: toDisplayString($options.secondLabelText),\n                        tabindex: \"-1\"\n                      }, null, 8 /* PROPS */, [\"textContent\"]),\n                      (openBlock(true), createBlock(Fragment, null, renderList($data.seconds, (s, sIndex) => {\n                        return (openBlock(), createBlock(Fragment, { key: sIndex }, [\n                          (!$options.opts.hideDisabledSeconds || ($options.opts.hideDisabledSeconds && !$options.isDisabled('second', s)))\n                            ? (openBlock(), createBlock(\"li\", {\n                                key: 0,\n                                class: {active: $data.second === s},\n                                tabindex: $options.isDisabled('second', s) ? -1 : $props.tabindex,\n                                \"data-key\": s,\n                                disabled: $options.booleanAttr($options.isDisabled('second', s)),\n                                textContent: toDisplayString(s),\n                                onClick: $event => ($options.select('second', s)),\n                                onKeydown: [\n                                  withKeys(withModifiers($event => ($options.select('second', s)), [\"prevent\"]), [\"space\"]),\n                                  withKeys(withModifiers($event => ($options.select('second', s)), [\"prevent\"]), [\"enter\"]),\n                                  withKeys(withModifiers($event => ($options.prevItem('second', s)), [\"prevent\"]), [\"up\"]),\n                                  withKeys(withModifiers($event => ($options.nextItem('second', s)), [\"prevent\"]), [\"down\"]),\n                                  _cache[30] || (_cache[30] = withKeys(withModifiers($event => ($options.toLeftColumn('second')), [\"prevent\"]), [\"left\"])),\n                                  _cache[31] || (_cache[31] = withKeys(withModifiers($event => ($options.toRightColumn('second')), [\"prevent\"]), [\"right\"])),\n                                  _cache[32] || (_cache[32] = withKeys(withModifiers((...args) => ($options.debounceBlur(...args)), [\"exact\"]), [\"esc\"]))\n                                ],\n                                onBlur: _cache[33] || (_cache[33] = (...args) => ($options.debounceBlur(...args))),\n                                onFocus: _cache[34] || (_cache[34] = (...args) => ($options.keepFocusing(...args)))\n                              }, null, 42 /* CLASS, PROPS, HYDRATE_EVENTS */, [\"tabindex\", \"data-key\", \"disabled\", \"textContent\", \"onClick\", \"onKeydown\"]))\n                            : createCommentVNode(\"v-if\", true)\n                        ], 64 /* STABLE_FRAGMENT */))\n                      }), 128 /* KEYED_FRAGMENT */))\n                    ], 32 /* HYDRATE_EVENTS */))\n                  : createCommentVNode(\"v-if\", true),\n                (column === 'apm')\n                  ? (openBlock(), createBlock(\"ul\", {\n                      key: 3,\n                      class: \"apms\",\n                      tabindex: \"-1\",\n                      onScroll: _cache[41] || (_cache[41] = (...args) => ($options.keepFocusing(...args)))\n                    }, [\n                      createVNode(\"li\", {\n                        class: \"hint\",\n                        textContent: toDisplayString($options.apmLabelText),\n                        tabindex: \"-1\"\n                      }, null, 8 /* PROPS */, [\"textContent\"]),\n                      (openBlock(true), createBlock(Fragment, null, renderList($data.apms, (a, aIndex) => {\n                        return (openBlock(), createBlock(Fragment, { key: aIndex }, [\n                          (!$options.opts.hideDisabledHours || ($options.opts.hideDisabledHours && !$options.isDisabled('apm', a)))\n                            ? (openBlock(), createBlock(\"li\", {\n                                key: 0,\n                                class: {active: $data.apm === a},\n                                tabindex: $options.isDisabled('apm', a) ? -1 : $props.tabindex,\n                                \"data-key\": a,\n                                disabled: $options.booleanAttr($options.isDisabled('apm', a)),\n                                textContent: toDisplayString($options.apmDisplayText(a)),\n                                onClick: $event => ($options.select('apm', a)),\n                                onKeydown: [\n                                  withKeys(withModifiers($event => ($options.select('apm', a)), [\"prevent\"]), [\"space\"]),\n                                  withKeys(withModifiers($event => ($options.select('apm', a)), [\"prevent\"]), [\"enter\"]),\n                                  withKeys(withModifiers($event => ($options.prevItem('apm', a)), [\"prevent\"]), [\"up\"]),\n                                  withKeys(withModifiers($event => ($options.nextItem('apm', a)), [\"prevent\"]), [\"down\"]),\n                                  _cache[36] || (_cache[36] = withKeys(withModifiers($event => ($options.toLeftColumn('apm')), [\"prevent\"]), [\"left\"])),\n                                  _cache[37] || (_cache[37] = withKeys(withModifiers($event => ($options.toRightColumn('apm')), [\"prevent\"]), [\"right\"])),\n                                  _cache[38] || (_cache[38] = withKeys(withModifiers((...args) => ($options.debounceBlur(...args)), [\"exact\"]), [\"esc\"]))\n                                ],\n                                onBlur: _cache[39] || (_cache[39] = (...args) => ($options.debounceBlur(...args))),\n                                onFocus: _cache[40] || (_cache[40] = (...args) => ($options.keepFocusing(...args)))\n                              }, null, 42 /* CLASS, PROPS, HYDRATE_EVENTS */, [\"tabindex\", \"data-key\", \"disabled\", \"textContent\", \"onClick\", \"onKeydown\"]))\n                            : createCommentVNode(\"v-if\", true)\n                        ], 64 /* STABLE_FRAGMENT */))\n                      }), 128 /* KEYED_FRAGMENT */))\n                    ], 32 /* HYDRATE_EVENTS */))\n                  : createCommentVNode(\"v-if\", true)\n              ], 64 /* STABLE_FRAGMENT */))\n            }), 128 /* KEYED_FRAGMENT */))\n          : createCommentVNode(\"v-if\", true),\n        createCommentVNode(\" / Advanced Keyboard Support \")\n      ], 4 /* STYLE */)\n    ], 38 /* CLASS, STYLE, HYDRATE_EVENTS */), [\n      [vShow, $data.showDropdown]\n    ])\n  ], 4 /* STYLE */))\n}\n\nscript.render = render;\nscript.__file = \"src/VueTimepicker.vue\";\n\nexport default script;\n//# sourceMappingURL=VueTimepikcer.esm.js.map\n"],"names":["getDevtoolsGlobalHook","getTarget","__VUE_DEVTOOLS_GLOBAL_HOOK__","navigator","window","g","isProxyAvailable","Proxy","HOOK_SETUP","HOOK_PLUGIN_SETTINGS_SET","supported","perf","isPerformanceSupported","_a","undefined","performance","perf_hooks","now","Date","ApiProxy","constructor","plugin","hook","this","target","targetQueue","onQueue","defaultSettings","settings","id","item","defaultValue","localSettingsSaveId","currentSettings","Object","assign","raw","localStorage","getItem","data","JSON","parse","e","fallbacks","getSettings","setSettings","value","setItem","stringify","on","pluginId","proxiedOn","get","_target","prop","args","push","method","proxiedTarget","keys","includes","resolve","Promise","async","setupDevtoolsPlugin","pluginDescriptor","setupFn","descriptor","enableProxy","enableEarlyProxy","__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__","proxy","list","__VUE_DEVTOOLS_PLUGINS__","emit","defaultOnError","error","defaultOnWarn","msg","createCompilerError","code","loc","messages","additionalMessage","SyntaxError","String","FRAGMENT","Symbol","TELEPORT","SUSPENSE","KEEP_ALIVE","BASE_TRANSITION","OPEN_BLOCK","CREATE_BLOCK","CREATE_ELEMENT_BLOCK","CREATE_VNODE","CREATE_ELEMENT_VNODE","CREATE_COMMENT","CREATE_TEXT","CREATE_STATIC","RESOLVE_COMPONENT","RESOLVE_DYNAMIC_COMPONENT","RESOLVE_DIRECTIVE","RESOLVE_FILTER","WITH_DIRECTIVES","RENDER_LIST","RENDER_SLOT","CREATE_SLOTS","TO_DISPLAY_STRING","MERGE_PROPS","NORMALIZE_CLASS","NORMALIZE_STYLE","NORMALIZE_PROPS","GUARD_REACTIVE_PROPS","TO_HANDLERS","CAMELIZE","CAPITALIZE","TO_HANDLER_KEY","SET_BLOCK_TRACKING","PUSH_SCOPE_ID","POP_SCOPE_ID","WITH_CTX","UNREF","IS_REF","WITH_MEMO","IS_MEMO_SAME","helperNameMap","registerRuntimeHelpers","helpers","getOwnPropertySymbols","forEach","s","locStub","source","start","line","column","offset","end","createRoot","children","type","components","directives","hoists","imports","cached","temps","codegenNode","createVNodeCall","context","tag","props","patchFlag","dynamicProps","isBlock","disableTracking","isComponent","helper","getVNodeBlockHelper","inSSR","getVNodeHelper","createArrayExpression","elements","createObjectExpression","properties","createObjectProperty","key","createSimpleExpression","content","isStatic","constType","createCompoundExpression","createCallExpression","callee","arguments","createFunctionExpression","params","returns","newline","isSlot","createConditionalExpression","test","consequent","alternate","createCacheExpression","index","isVNode","createBlockStatement","body","isStaticExp","p","isBuiltInType","expected","isCoreComponent","nonIdentifierRE","isSimpleIdentifier","name","validFirstIdentCharRE","validIdentCharRE","whitespaceRE","isMemberExpressionBrowser","path","trim","replace","state","stateStack","currentOpenBracketCount","currentOpenParensCount","currentStringType","i","length","char","charAt","pop","isMemberExpression","getInnerRange","slice","newLoc","advancePositionWithClone","pos","numberOfCharacters","advancePositionWithMutation","linesCount","lastNewLinePos","charCodeAt","findDir","node","allowEmpty","exp","findProp","dynamicOnly","isStaticArgOf","arg","hasDynamicKeyVBind","some","isText","isVSlot","isTemplateNode","tagType","isSlotOutlet","ssr","propsHelperSet","Set","getUnnormalizedProps","callPath","has","concat","injectProp","propsWithInjection","parentCall","ret","first","unshift","hasProp","result","propKeyName","toValidAssetId","searchValue","replaceValue","toString","getMemoedVNodeCall","makeBlock","removeHelper","getCompatValue","config","options","compatConfig","isCompatEnabled","mode","checkCompatEnabled","enabled","decodeRE","decodeMap","gt","lt","amp","apos","quot","defaultParserOptions","delimiters","getNamespace","getTextMode","isVoidTag","NO","isPreTag","isCustomElement","decodeEntities","rawText","_","p1","onError","onWarn","comments","createParserContext","getCursor","parseChildren","getSelection","rawOptions","originalSource","inPre","inVPre","ancestors","parent","last","ns","nodes","isEnd","startsWith","parseInterpolation","emitError","parseComment","parseBogusComment","parseCDATA","advanceBy","parseTag","parseElement","isSpecialTemplateDirective","parseText","pushNode","removedWhitespace","shouldCondense","whitespace","prev","next","filter","Boolean","match","exec","prevIndex","nestedIndex","indexOf","contentStart","closeIndex","wasInPre","wasInVPre","element","isPreBoundary","isVPreBoundary","isSelfClosing","inlineTemplateProp","find","startsWithEndTagOpen","toLowerCase","advanceSpaces","cursor","currentSource","parseAttributes","isBuiltInComponent","isNativeTag","attributeNames","attr","parseAttribute","nameSet","add","pattern","m","parseAttributeValue","isPropShorthand","dirName","startOffset","lastIndexOf","getNewPosition","endsWith","isQuoted","valueLoc","modifiers","split","splice","quote","endIndex","parseTextData","unexpectedChars","open","close","innerStart","innerEnd","rawContentLength","rawContent","preTrimContent","endOffset","endTokens","xs","searchString","hoistStatic","root","walk","isSingleElementRoot","child","doNotHoistNode","originalCount","hoistedCount","constantType","getConstantType","hoist","flag","getPatchFlag","getGeneratedPropsConstantType","getNodeProps","scopes","vSlot","branches","transformHoist","constantCache","set","returnType","generatedPropsType","childType","expType","allowHoistedHelperSet","getConstantTypeOfHelperCall","keyType","valueType","parseInt","createTransformContext","filename","prefixIdentifiers","cacheHandlers","nodeTransforms","directiveTransforms","expressionPlugins","scopeId","slotted","ssrCssVars","bindingMetadata","inline","isTS","nameMatch","selfName","Map","identifiers","create","vFor","vPre","vOnce","currentNode","childIndex","inVOnce","count","currentCount","delete","helperString","replaceNode","removeNode","removalIndex","onNodeRemoved","addIdentifiers","removeIdentifiers","identifier","hoisted","cache","filters","transform","traverseNode","createRootCodegen","traverseChildren","nodeRemoved","exitFns","onExit","createStructuralDirectiveTransform","fn","matches","n","PURE_ANNOTATION","aliasHelper","createCodegenContext","ast","sourceMap","optimizeImports","runtimeGlobalName","runtimeModuleName","ssrRuntimeModuleName","indentLevel","pure","map","indent","deindent","withoutNewLine","repeat","generate","onContextCreated","hasHelpers","useWithBlock","preambleContext","genFunctionPreamble","functionName","signature","join","genAssets","genNode","preamble","toJSON","VueBinding","staticHelpers","genHoists","assets","resolver","maybeSelfReference","genNodeListAsArray","multilines","genNodeList","comma","genText","genExpression","genInterpolation","genCompoundExpression","genComment","genVNodeCall","genCallExpression","genObjectExpression","genArrayExpression","genFunctionExpression","genConditionalExpression","genCacheExpression","genExpressionAsPropertyKey","text","callHelper","genNullableArgs","isNonScopedSlot","needNewline","needsParens","isNested","RegExp","transformIf","dir","processIf","ifNode","branch","isRoot","siblings","sibling","createCodegenNodeForBranch","parentCondition","getParentCondition","processCodegen","createIfBranch","condition","isTemplateIf","userKey","keyIndex","createChildrenCodegenNode","keyProperty","firstChild","needFragmentWrapper","vnodeCall","transformFor","processFor","forNode","renderExp","isTemplate","memo","keyProp","keyExp","isStableFragment","fragmentFlag","childBlock","slotOutlet","loop","createForLoopParams","parseResult","parseForExpression","valueAlias","keyAlias","objectIndexAlias","forAliasRE","forIteratorRE","stripParensRE","input","inMatch","LHS","RHS","createAliasExpression","valueContent","trimmedOffset","iteratorMatch","keyContent","keyOffset","indexContent","range","memoArgs","createParamsList","defaultFallback","trackSlotScopes","buildClientSlotFn","buildSlots","buildSlotFn","slotsProperties","dynamicSlots","hasDynamicSlots","onComponentSlot","hasTemplateSlots","hasNamedDefaultSlot","implicitDefaultChildren","seenSlotNames","conditionalBranchIndex","slotElement","slotDir","slotChildren","slotLoc","slotName","slotProps","dirLoc","staticSlotName","slotFunction","vIf","vElse","buildDynamicSlot","j","conditional","buildDefaultSlotProperty","isNonWhitespaceContent","slotFlag","hasForwardedSlots","slots","directiveImportMap","WeakMap","transformElement","vnodeTag","resolveComponentType","isDynamicComponent","vnodeProps","vnodeChildren","vnodePatchFlag","vnodeDynamicProps","dynamicPropNames","vnodeDirectives","shouldUseBlock","propsBuildResult","buildProps","buildDirectiveArgs","shouldBuildAsSlots","hasDynamicTextChild","stringifyDynamicPropNames","isExplicitDynamic","isComponentTag","isProp","isDir","builtIn","elementLoc","mergeArgs","runtimeDirectives","hasChildren","hasRef","hasClassBinding","hasStyleBinding","hasHydrationEventBinding","hasDynamicKeys","hasVnodeHook","pushMergeArg","dedupeProperties","analyzePatchFlag","isEventHandler","isVBind","isVOn","directiveTransform","needRuntime","propsExpression","classKeyIndex","styleKeyIndex","hasDynamicKey","isHandlerKey","classProp","styleProp","knownProps","deduped","existing","mergeAsArray","incoming","dirArgs","runtime","trueExpression","modifier","propsNamesString","l","cacheStringFunction","str","hit","camelizeRE","camelize","c","toUpperCase","transformSlotOutlet","processSlotOutlet","slotArgs","expectedLen","nonNameProps","fnExpRE","transformOn","augmentor","eventName","rawName","eventString","shouldCache","isMemberExp","isInlineStatement","hasMultipleStatements","transformBind","_node","injectPrefix","prefix","transformText","currentContainer","hasText","callArgs","seen","WeakSet","transformOnce","cur","transformModel","createTransformProps","rawExp","expString","bindingType","maybeRef","propName","assignmentExp","eventArg","modifiersKey","validDivisionCharRE","transformFilter","rewriteFilter","parseFilter","expression","inSingle","inDouble","inTemplateString","inRegex","curly","square","paren","lastFilterIndex","pushFilter","wrapFilter","seen$1","transformMemo","getBaseTransformPreset","bind","model","baseCompile","template","isModuleMode","noopDirectiveTransform","V_MODEL_RADIO","V_MODEL_CHECKBOX","V_MODEL_TEXT","V_MODEL_SELECT","V_MODEL_DYNAMIC","V_ON_WITH_MODIFIERS","V_ON_WITH_KEYS","V_SHOW","TRANSITION","TRANSITION_GROUP","decoder","decodeHtmlBrowser","asAttr","document","createElement","innerHTML","getAttribute","textContent","isRawTextContainer","parserOptions","a","transformStyle","parseInlineCSS","cssText","normalized","createDOMCompilerError","transformVHtml","transformVText","baseResult","directiveToUse","isInvalidType","isEventOptionModifier","isNonKeyModifier","maybeKeyModifier","isKeyboardEvent","resolveModifiers","keyModifiers","nonKeyModifiers","eventOptionModifiers","transformClick","event","isStaticClick","handlerExp","modifierPostfix","transformShow","ignoreSideEffectTags","DOMNodeTransforms","DOMDirectiveTransforms","cloak","html","show","compile","compileCache","compileToFunction","nodeType","el","querySelector","opts","customElements","render","Function","_rc","CONFIG","HOUR_TOKENS","MINUTE_TOKENS","SECOND_TOKENS","APM_TOKENS","BASIC_TYPES","DEFAULT_OPTIONS","format","minuteInterval","secondInterval","hourRange","minuteRange","secondRange","hideDisabledHours","hideDisabledMinutes","hideDisabledSeconds","hideDisabledItems","advancedKeyboard","hideDropdown","blurDelay","manualInputTimeout","dropOffsetHeight","script","modelValue","Number","Array","default","hideClearButton","disabled","closeOnComplete","inputClass","placeholder","tabindex","inputWidth","autocomplete","hourLabel","minuteLabel","secondLabel","apmLabel","amText","pmText","lazy","autoScroll","dropDirection","containerId","manualInput","fixedDropdownButton","debugMode","timeValue","hours","minutes","seconds","apms","isActive","showDropdown","isFocusing","debounceTimer","hourType","minuteType","secondType","apmType","hour","minute","second","apm","fullValues","bakDisplayTime","doClearApmChecking","selectionTimer","kbInputTimer","kbInputLog","bakCurrentPos","forceDropOnTop","emits","computed","isNumber","debugLog","isArray","useStringValue","formatString","inUse","typesInUse","getTokenByType","sort","r","tokensInUse","types","tokens","displayTime","customDisplayTime","apmDisplayText","inputIsEmpty","allValueSelected","columnsSequence","showClearBtn","showDropdownBtn","baseOn12Hours","hourRangeIn24HrFormat","is12hRange","translate12hRange","restrictedHourRange","validHoursList","hr","substr","formatValue","am12Index","shift","customApmText","apmEnabled","am","pm","minuteRangeList","renderRangeList","secondRangeList","hourLabelText","minuteLabelText","secondLabelText","apmLabelText","inputWidthStyle","width","tokenRegexBase","tokenChunks","tokensRegxStr","tokensMatchAll","getMatchAllByRegex","tkMatch","rawToken","tokenMatchItem","token","getTokenType","needsCalibrate","len","needsPosCalibrate","chk","tokenChunksPos","calibrateLen","chunkCurrentLen","invalidValues","isEmptyValue","isValidValue","isDisabled","notInInterval","hasInvalidInput","autoDirectionEnabled","dropdownDirClass","watch","newValue","renderFormat","newInteval","renderList","deep","handler","readValues","fillValues","toDisabled","newLength","oldLength","$emit","methods","checkAcceptingType","validValues","newFormat","renderHoursList","renderApmList","nextTick","hoursCount","listType","interval","isMinuteOrSecond","isMinute","readStringValues","readObjectValues","objValue","values","sanitizedValue","addFallbackValues","testString","regexString","needsPolyfill","matchAll","polyfillMatchAll","stringValue","othersRegxStr","othersMatchAll","chunks","isValueToken","otMatch","regexCombo","chunk","tokenRegex","getTokenRegex","safeChars","comboReg","matchResults","valueResults","vrIndex","targetToken","setValueFromString","tokenChunksForLog","tChunk","targetString","regxStr","matchesList","indicesReg","matchedItem","existIndex","findIndex","idxItem","regex","itemIndicesRegex","parsedValue","tokenType","stdValue","forceEmit","baseHour","baseHourType","apmValue","hourValue","lowerCasedApm","A","mm","ss","emitTimeValue","toggleActive","valueT","match12hRange","isBasicType","isDisabledHour","section","rawRange","formatedValue","fullList","validItems","forceApmSelection","emptyApmSelection","setDropdownState","$refs","selectionStart","selectionEnd","selectFirstSlot","checkForAutoScroll","toShow","fromUserClick","keepFocusing","checkDropDirection","blurEvent","select","clearTime","scrollToSelectedValues","firstColumn","scrollToSelected","allowFallback","targetList","$el","querySelectorAll","targetValue","activeItemInCol","validItemsInCol","scrollTop","offsetTop","focus","onFocus","escBlur","clearTimeout","inputBox","blur","debounceBlur","setTimeout","onBlur","columnClass","getClosestSibling","dataKey","getPrevious","siblingsInCol","selfIndex","prototype","call","sbl","prevItem","isManualInput","targetItem","nextItem","getSideColumnName","currentColumn","toLeft","currentColumnIndex","getFirstItemInSideColumn","targetColumn","listItems","getActiveItemInSideColumn","activeItems","toLeftColumn","toRightColumn","onMouseDown","nearestSlot","getNearestChunkByPos","debounceSetInputSelection","keyDownHandler","evt","isComposing","keyCode","preventDefault","stopPropagation","keyboardInput","clearKbInputLog","arrowHandler","tabHandler","metaKey","ctrlKey","onCompostionStart","getCurrentTokenChunk","onCompostionEnd","cpsData","inputIsCustomApmText","isCustomApmText","setSanitizedValueToSection","bakPos","pasteHandler","pastingText","clipboardData","getData","replaceCustomApmText","setKbInput","debounceClearKbLog","direction","selectFirstValidValue","currentChunk","getClosestValidItemInCol","newChunkPos","toLateralToken","firstChunk","lastChunk","shiftKey","newChar","isApm","chunkType","chunkToken","validValue","lastInputValue","onChange","autoFillValue","startPos","nearest","nearestDelta","delta","Math","abs","firstSlotType","getClosestHourItem","currentValue","setManualHour","currentIndex","valueKey","nextIndex","inputValue","hourT","setInputSelectionRange","setSelectionRange","firstChunkPos","currentChunkIndex","targetSlotPos","inputData","inputString","container","getElementById","spaceDown","offsetHeight","docHeight","max","scrollHeight","documentElement","clientHeight","isNaN","parseFloat","isFinite","testValue","tokenRegexStr","booleanAttr","isTrue","logText","inputClasses","clsName","finalLogText","console","debug","log","mounted","beforeUnmount","_hoisted_1","class","_hoisted_2","createVNode","_hoisted_3","_hoisted_4","_ctx","_cache","$props","$setup","$data","$options","openBlock","createBlock","style","$slots","icon","ref","readonly","$event","onMousedown","onKeydown","withKeys","withModifiers","onCompositionstart","onCompositionend","onPaste","clearButton","onClick","renderSlot","createCommentVNode","dropdownButton","withDirectives","onMouseup","Fragment","onScroll","toDisplayString","hIndex","active","mIndex","sIndex","aIndex","vShow","__file"],"sourceRoot":""}